I have a form that is used to create a memo, to do that I am using a rich text editor to provide some styling, this creates html tags in order to apply style. When I post that text, the mvc throws an error to prevent potentially dangerous scripts, so I have to specifically allow it. 

I have found 2 ways of doing this, one is to decorate the controller method with `[ValidateInput(false)]` and the other is to decorate the `ViewModel` attribute with `[AllowHtml]`. To me, `[AllowHtml]` looks much nicer, but I have only found that approach used 1 time and the `[ValidateInput(false)]` seems to be the preferred way.

Which method should I use and what are the differences between the two?

ValidateInput(false) vs AllowHtml

As a fairly experienced ASP.Net developer just recently starting using MVC, I find myself struggling a bit to change my mindset from a traditional &quot;server control and event handler&quot; way of doing things, into the more dynamic MVC way of things. I think I am slowly getting there, but sometimes the MVC &quot;magic&quot; throws me off.

My current scenario is to create a web page that allows the user to browse a local file, upload it to the server and repeat this until he has a list of files to work with. When he is happy with the file list (which will be displayed in a grid on the page), he will click a button to process the files and extract some data that will be stored in a database.

The last part is not so important, right now I am struggling with something as trivial as building up a list of files, and persisting that list between requests. In the traditional approach this would be extremely simple - the data would be persisted in ViewState. But in MVC I need to pass the data between the controller and the views, and I don&#39;t fully get how this is supposed to work.

I guess I better post my rather incomplete attempt of coding this to explain the problem.

In order to keep my file list data, I have created a viewmodel that is basically a typed list of files, along with some extra metadata:

    public class ImportDataViewModel
    {
        public ImportDataViewModel()
        {
            Files = new List&lt;ImportDataFile&gt;();
        }

        public List&lt;ImportDataFile&gt; Files { get; set; }
    ...

In the view, I have a form for browsing and uploading the file:

    &lt;form action=&quot;AddImportFile&quot; method=&quot;post&quot; enctype=&quot;multipart/form-data&quot;&gt;
      &lt;label for=&quot;file&quot;&gt;
        Filename:&lt;/label&gt;
      &lt;input type=&quot;file&quot; name=&quot;file&quot; id=&quot;file&quot; /&gt;
      &lt;input type=&quot;submit&quot; /&gt;
      &lt;/form&gt;

The view is using the viewmodel as its model:

    @model MHP.ViewModels.ImportDataViewModel

This will send the file to my action:

    public ActionResult AddImportFile(HttpPostedFileBase file, ImportDataViewModel importData)
        {

            if (file.ContentLength &gt; 0)
            {
                ImportDataFile idFile = new ImportDataFile { File = file };
                importData.Files.Add(idFile);
            }

            return View(&quot;DataImport&quot;, importData);
        }

This action returns the view for the DataImport page along with the viewmodel instance containing the list of files.

This works nicely up to a certain point, I can browse a file and upload it, and I can see the viewmodel data inside the action, and then also if I put a breakpoint inside the view and debug &quot;this.Model&quot;, everything is fine.

But then, if I try to upload another file, when putting a breakpoint inside the AddImportFile action, the importData parameter is empty. So the view is obviously not passing the current instance of its model to the action. 

In the MVC samples I have been through, the model instance is &quot;magically&quot; passed to the action method as a parameter, so why is it empty now?

I assume the real problem is my limited understanding of MVC, and that there is probably a very simple solution to this. Anyways, I would be extremely grateful if somebody could point me in the right direction.










ASP.Net MVC and state - how to keep state between requests

I want to initialize ViewModel in Activity using androidx library

I have tried what documentation says but it is not working. the &quot;.of&quot; is not resolved.
 

```kotlin
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import androidx.databinding.DataBindingUtil
import androidx.lifecycle.ViewModelProvider
import com.example.myapplication.databinding.ActivityMainBinding`

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val binding: ActivityMainBinding = DataBindingUtil.setContentView(
            this, R.layout.activity_main)
        binding.setLifecycleOwner(this)

        var model = ViewModelProvider.of(this).get(SheduleViewModel::class.java)

    }
}
```



of is not resolved, maybe there are another way to do it in androidx



how to instantiate ViewModel In AndroidX?

This might be a stupid question! (n00b to AutoMapper and time-short!)

I want to use AutoMapper to map from EF4 entities to ViewModel classes.

1) If I call

    CreateMap&lt;ModelClass, ViewModelClass&gt;()

then do I also need to call

    CreateMap&lt;ViewModelClass, ModelClass&gt;()

to perform the reverse?

2) If two classes have the same property names, then do I need a CreateMap statement at all, or is this just for &quot;specific/custom&quot; mappings?



Do i need to create automapper createmap both ways?

A common senario: A model with a collection of item models.  
E.g a House with a collection of People.

**How to structure this correctly for MVVM - particulary with regard to updating the Model and ViewModel collections with additions and deletes?**

Model `House` contains a collection of model `People` (normally a `List&lt;People&gt;`).  
View model `HouseVM` contains the House object that it wraps and an ObservableCollection of view model `PeopleVM` (`ObservableCollection&lt;PeopleVM&gt;`).  Note that we end up here with the HouseVM holding two collections (that require syncing):  
1. `HouseVM.House.List&lt;People&gt;`  
2. `HouseVM.ObservableCollection&lt;PeopleVM&gt;`

When the House is updated with new People (add) or People leave (remove) that event must now be handled in both collections the Model House People collection **AND** the the VM HouseVM PeopleVM ObservableCollection.

**Is this structure correct MVVM?  
Is there anyway to avoid having to do the double update for Adds and Removes?**

MVVM and collections of VMs

With the introduction of the Android Architecture Components library, several new classes were introduced, including `AndroidViewModel` and `ViewModel`. However, I&#39;m having trouble figuring out the difference between these two classes. The [documentation][1] succinctly describes `AndroidViewModel` as follows:

&gt; Application context aware `ViewModel`

I appreciate the brevity, but what exactly does this imply? When should we choose to use `AndroidViewModel` over `ViewModel` and vice-versa?

  [1]: https://developer.android.com/reference/android/arch/lifecycle/AndroidViewModel.html

AndroidViewModel vs ViewModel

Is there a way to pass additional argument to my custom `AndroidViewModel` constructor except Application context. 
Example:

    public class MyViewModel extends AndroidViewModel {
        private final LiveData&lt;List&lt;MyObject&gt;&gt; myObjectList;
        private AppDatabase appDatabase;

        public MyViewModel(Application application, String param) {
            super(application);
            appDatabase = AppDatabase.getDatabase(this.getApplication());
            
            myObjectList = appDatabase.myOjectModel().getMyObjectByParam(param);
        }
    }

And when I want to user my custom `ViewModel` class I use this code in my fragment:

    MyViewModel myViewModel = ViewModelProvider.of(this).get(MyViewModel.class)


So I don&#39;t know how to pass additional argument `String param` into my custom `ViewModel`. I can only pass Application context, but not additional arguments. I would really appreciate any help. Thank you. 


Edit: I&#39;ve added some code. I hope it&#39;s better now.

Android ViewModel additional arguments

Hey I&#39;m trying to get my ViewModel working, but no luck so far. 
Android Studio shows error `Cannot resolve symbol &#39;ViewModelProviders&#39;`. 

Every other question I found on this topic was correcting `extends Activity` to `extends AppCompatActivity`, but I am extending the right one. Not sure what I&#39;m missing...  
My code is based on [This YouTube video][1]

**MainActivity.java** 

    public class MainActivity extends AppCompatActivity implements
        TileAdapter.TileAdapterOnClickHandler {

   
    private BaseViewModel viewModel;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //set Toolbar
        Toolbar myToolbar = findViewById(R.id.toolbar);
        setSupportActionBar(myToolbar);


        //initialize viewModel
        viewModel = ViewModelProviders.of(this).get(BaseViewModel.class);

**BaseViewModel.java**

    public class BaseViewModel extends ViewModel {

    private Movie[] mMovie;

    public void init (Movie[] movies){
        this.mMovie = movies;
    }

    public Movie[] getMovie() {
        return mMovie;
    }


  [1]: https://youtu.be/c9-057jC1ZA

Cannot resolve symbol ViewModelProviders on AppCompatActivity

I&#39;m using NHibernate to persist my domain objects.
To keep things simple I&#39;m using an ASP.NET MVC project as both my presentation layer, and my service layer.

I want to return my domain objects in XML from my controller classes. After reading some posts here on Stack Overflow I gather DTOs are the way to go. However, I&#39;ve also come across posts talking about the ViewModel.

My question: Are Data Transfer Objects and ViewModels the same thing? Or is a ViewModel a kind of sub pattern of a DTO?

DTO = ViewModel?

I am confused to understand what is the meaning of this words:

`Entity`, `Model`, `DataModel`, `ViewModel`

Can any body help me to understanding them please? Thank you all.

what is difference between a Model and an Entity

Recently I am exploring Android Architecture, that has been introduced recently by google. From the [Documentation][1] I have found this:

    public class MyViewModel extends ViewModel {
        private MutableLiveData&lt;List&lt;User&gt;&gt; users;
        public LiveData&lt;List&lt;User&gt;&gt; getUsers() {
            if (users == null) {
                users = new MutableLiveData&lt;List&lt;Users&gt;&gt;();
                loadUsers();
            }
            return users;
        }
    
        private void loadUsers() {
            // do async operation to fetch users
        }
    }
the activity can access this list as follows:

    public class MyActivity extends AppCompatActivity {
        public void onCreate(Bundle savedInstanceState) {
            MyViewModel model = ViewModelProviders.of(this).get(MyViewModel.class);
            model.getUsers().observe(this, users -&gt; {
                // update UI
            });
        }
    }

My Question is, I am going to do this: 

1. in the `loadUsers()` function I am fetching the data asynchronously where I will first check the database(Room) for that data

2. If I do not get the data there I will make an API call to fetch the data from the web server.

3. I will insert the fetched data into the database(Room) and update the UI according the data. 

What is the recommended approach to do this?

If I start a `Service` to call the API from the `loadUsers()` method, how can I update the `MutableLiveData&lt;List&lt;User&gt;&gt; users` variable from that `Service`?

  [1]: https://developer.android.com/topic/libraries/architecture/viewmodel.html

How to update LiveData of a ViewModel from background service and Update UI

I am new to ASP.NET MVC. I have a problem with understanding the purpose of a ViewModel. 

What is a ViewModel and why do we need a ViewModel for an ASP.NET MVC Application? 

If I get a good example about its working and explanation that would be better.

What is ViewModel in MVC?

OK, I have been hearing discussion about &quot;ViewModels&quot; in regards to MS&#39;s ASP.NET MVC.

Now, that is intended to be a specific kind of Model, correct?  Not a specific kind of View.

To my understanding, it&#39;s a kind of Model that has a specific purpose of interacting with the View?  Or something like that?

Some clarification would be appreciated.

ASP.NET MVC Model vs ViewModel

I have 2 models:

    public class Person
    {
        public int PersonID { get; set; }
        public string PersonName { get; set; }
    }
    public class Order
    {
        public int OrderID { get; set; }
        public int TotalSum { get; set; }
    }

I want edit objects of BOTH classes in SINGLE view, so I need something like:

    @model _try2models.Models.Person
    @model _try2models.Models.Order
    
    @using(Html.BeginForm())
    {
        @Html.EditorFor(x =&gt; x.PersonID)
        @Html.EditorFor(x =&gt; x.PersonName)
        @Html.EditorFor(x=&gt;x.OrderID)
        @Html.EditorFor(x =&gt; x.TotalSum)
    }
This, of course, don&#39;t work: Only one &#39;model&#39; statement is allowed in a .cshtml file. May be there is some workaround?

Two models in one view in ASP MVC 3

Every article found in the Internet on using ViewModels and utilizing Automapper gives the guidelines of the &quot;Controller -&gt; View&quot; direction mapping. You take a  domain model along with all Select Lists into one specialized ViewModel and pass it to the view. That&#39;s clear and fine.  
The view has a form, and eventually we are in the POST action. Here all the Model Binders come to the scene along with *[obviously] another* View Model which is *[obviously] related* to the original ViewModel at least in the part of naming conventions for the sake of binding and validation.

**How do you map it to your Domain Model?**

Let it be an insert action, we could use the same Automapper. But what if it was an update action? We have to retrieve our Domain Entity from the Repository, update it&#39;s properties according to the values in the ViewModel and save to the Repository.

**ADDENDUM 1 (9th of February 2010):** Sometimes, assigning Model&#39;s properties is not enough. There should be taken some action against Domain Model according to the values of View Model. I.e., some methods should be called on Domain Model. Probably, there should be a kind of an Application Service layer which stands between Controller and Domain in order to process View Models...

----------

**How to organize this code and where to place it to achieve the following goals?**

 - keep controllers thin
 - honor SoC practice
 - follow Domain-Driven Design principles
 - be DRY
 - to be continued ...

How to map View Model back to Domain Model in a POST action?

I have been trying to create an Object of ViewModel in an Activity but ViewModelProviders is deprecated So what&#39;s the alternative to create the ViewModel&#39;s object.

As ViewModelProviders.of() is deprecated, how should I create object of ViewModel?

We have been discussing about this but we don&#39;t know the reason of creating a viewmodel factory to create a viewmodel instead of instantiate the viewmodel directly. What is the gain of creating a factory that just creates the viewmodel?

I just put a simple example of how I did it without Factory

here is the kodein module:

    val heroesRepositoryModel = Kodein {
        bind&lt;HeroesRepository&gt;() with singleton {
            HeroesRepository()
        }
    
        bind&lt;ApiDataSource&gt;() with singleton {
            DataModule.create()
        }
    
        bind&lt;MainViewModel&gt;() with provider {
            MainViewModel()
        }
    }

The piece of the Activity where I instantiate the viewmodel without using the factory 

    class MainActivity : AppCompatActivity() {
        private lateinit var heroesAdapter: HeroAdapter
        private lateinit var viewModel: MainViewModel
        private val heroesList = mutableListOf&lt;Heroes.MapHero&gt;()
        private var page = 0
        private var progressBarUpdated = false
    
        override fun onCreate(savedInstanceState: Bundle?) {
            super.onCreate(savedInstanceState)
            setContentView(R.layout.activity_main)
            viewModel = ViewModelProviders.of(this)
                    .get(MainViewModel::class.java)
            initAdapter()
            initObserver()
            findHeroes()
        }

The ViewModel where I instantiate the usecase directly without having it in the constructor

    class MainViewModel : ViewModel(), CoroutineScope {
    
        private val heroesRepository: HeroesRepository = heroesRepositoryModel.instance()
        val data = MutableLiveData&lt;List&lt;Heroes.MapHero&gt;&gt;()
    
        private var job: Job = Job()
        override val coroutineContext: CoroutineContext
            get() = uiContext + job
    
        fun getHeroesFromRepository(page: Int) {
            launch {
                try {
                    val response = heroesRepository.getHeroes(page).await()
                    data.value = response.data.results.map { it.convertToMapHero() }
                } catch (e: HttpException) {
                    data.value = null
                } catch (e: Throwable) {
                    data.value = null
                }
            }
        }
    
        override fun onCleared() {
            super.onCleared()
            job.cancel()
        }
    }


So here a example using factory

    class ListFragment : Fragment(), KodeinAware, ContactsAdapter.OnContactListener {
    
        override val kodein by closestKodein()
    
        private lateinit var adapterContacts: ContactsAdapter
    
        private val mainViewModelFactory: MainViewModelFactory by instance()
        private val mainViewModel: MainViewModel by lazy {
            activity?.run {
                ViewModelProviders.of(this, mainViewModelFactory)
                    .get(MainViewModel::class.java)
            } ?: throw Exception(&quot;Invalid Activity&quot;)
        }
    
        override fun onCreateView(
                inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
            return inflater.inflate(R.layout.fragment_list, container, false)
        }


The viewmodelfactory:

    class MainViewModelFactory (private val getContacts: GetContacts) : ViewModelProvider.Factory {
    
        override fun &lt;T : ViewModel?&gt; create(modelClass: Class&lt;T&gt;): T {
            if (modelClass.isAssignableFrom(MainViewModel::class.java)) {
                return MainViewModel(getContacts) as T
            }
            throw IllegalArgumentException(&quot;Unknown ViewModel class&quot;)
        }
    }

And the viewmodel:

    class MainViewModel(private val getContacts: GetContacts) : BaseViewModel() {
        lateinit var gamesList: LiveData&lt;PagedList&lt;Contact&gt;&gt;
        var contactsSelectedData: MutableLiveData&lt;List&lt;Contact&gt;&gt; = MutableLiveData()
        var contactsSelected: ArrayList&lt;Contact&gt; = ArrayList()
        private val pagedListConfig by lazy {
            PagedList.Config.Builder()
                    .setEnablePlaceholders(false)
                    .setInitialLoadSizeHint(PAGES_CONTACTS_SIZE)
                    .setPageSize(PAGES_CONTACTS_SIZE)
                    .setPrefetchDistance(PAGES_CONTACTS_SIZE*2)
                    .build()
        }

Here is the complete first example:

https://github.com/ibanarriolaIT/Marvel/tree/mvvm

And the complete second example:

https://github.com/AdrianMeizoso/Payment-App

Why a viewmodel factory is needed in Android?

I used to receive empty string when there was no value:

    [HttpPost]
    public ActionResult Add(string text)
    {
        // text is &quot;&quot; when there&#39;s no value provided by user
    }

But now I&#39;m passing a model

    [HttpPost]
    public ActionResult Add(SomeModel Model)
    {
        // model.Text is null when there&#39;s no value provided by user
    }

So I have to use the `?? &quot;&quot;` operator.

Why is this happening?

Why do I get null instead of empty string when receiving POST request in from Razor View?

I&#39;m using Automapper and I have the following scenario:
Class OrderModel has a property called &#39;ProductName&#39; that isn&#39;t in the database.
So when I try to do the mapping with:
 

    Mapper.CreateMap&lt;OrderModel, Orders&gt;(); 

It generates an exception :
 
&quot;The following 1 properties on Project.ViewModels.OrderModel are not mapped: &#39;ProductName&#39;

I&#39;ve read at [AutoMapper&#39;s Wiki for Projections][1] the opposite case (the extra attribute is on the destination, not in the source which is actually my case )

How can I avoid automapper to make the mapping of this property?


  [1]: https://github.com/AutoMapper/AutoMapper/wiki/Projection

Ignore mapping one property with Automapper

I&#39;ve been reading some explanations about the difference between User and Custom Controls, for example this:
http://www.wpftutorial.net/CustomVsUserControl.html 

I want to create, for example, a simple composition of a datagrid with 2 comboboxes which are responsible to change the values from the datagrid&#39;s items. I want to create a specific control for this because I&#39;m going to use it a lot of times. I would like to implement the logic behind and then in the xaml invocation I only have to specify the itemsSource.

For this example should I create a User or Custom control? Since I will have properties and logic, should I have a viewmodel for this control?

EDIT: Do you know some articles with clear conceptual separation between these 2 options?

Custom vs User control

I have a view `AttributeView` that contains all sorts of attributes. There&#39;s also a button that when pressed, it should set the default values to the attributes. I also have a `ViewModelBase` class that is a base class for all ViewModels I have.
The problem is I can&#39;t seem to get the button bound to the command with WPF.

I&#39;ve tried this, but it just doesn&#39;t do anything:

    &lt;Button Command=&quot;{Binding DataInitialization}&quot; Content=&quot;{x:Static localProperties:Resources.BtnReinitializeData}&quot;&gt;&lt;/Button&gt;

The command is defined (in the `ViewModelBase`) like this:

    public CommandBase DataInitialization { get; protected set; }

and on application startup a new instance is created for the command:

    DataInitialization = new DataInitializationCommand()

However, the WPF binding doesn&#39;t seem to &quot;find&quot; the command (pressing the button does nothing). The ViewModel used in the current view is derived from the `ViewModelBase`. What else I can try (I&#39;m quite new to WPF so this might be a very simple question)?

All Viewmodel Solutions on Gang of Coders

Total of 21 Viewmodel Solutions