How to declare an object using markup in ASP.NET

Question

Assume we have a Person class:

public class Person
{
  public string FamilyName {get;set;}
  public string GivenName {get;set;}
}

And there's a control to somehow display the information of a list of persons. Here is the pseudocode of the aspx:

<uc1:EmployeesViewer runat="server">
  <Employees>
    <Person>
      <GivenName>John</GivenName>
      <FamilyName>Kerry</GivenName>
    </Person>
    <Person>
      <GivenName>Jack</GivenName>  
      <FamilyName>Lew</GivenName>
    </Person>
  <Employees>
</uc1:EmployeesViewer>

EmployeesViewer.Employees is of type List<Person>, with the attribute [PersistenceMode(PersistenceMode.InnerProperty)].

But Visual Studio doesn't compile this. Is it possible to declare a Person object using markup?

Answer 1

Is it possible to declare a Person object using markup?

Yes, with only some minor changes to the markup (and no changes to your Person class):

<%@ Page Language="C#" CodeBehind="DemoPage.aspx.cs" Inherits="DemoApp.DemoPage" %>
<%@ Register TagPrefix="uc1" Assembly="DemoApp" Namespace="DemoApp" %>

<uc1:EmployeesViewer runat="server">
    <Employees>
        <uc1:Person GivenName="John" FamilyName="Kerry" />
        <uc1:Person GivenName="Jack" FamilyName="Lew" />
    </Employees>
</uc1:EmployeesViewer>

The uc1: tag prefix assumes that your Person class is in the same assembly and namespace as EmployeesViewer. If not, just <%@ Register %> another tag prefix for Person.

Note: You can use the <uc1:Person> syntax even though Person doesn't derive from Control:

namespace DemoApp
{
    public class Person
    {
        public string FamilyName {get;set;}
        public string GivenName {get;set;}
    }
}

Here's a simple EmployeesViewer control that renders the list of employees:

namespace DemoApp
{
    [ParseChildren(true)]
    [PersistChildren(false)]
    public class EmployeesViewer : Control
    {
        private readonly List<Person> _employees = new List<Person>();

        [PersistenceMode(PersistenceMode.InnerProperty)]
        public List<Person> Employees
        {
            get { return _employees; }
        }

        protected override void Render(HtmlTextWriter writer)
        {
            foreach (Person person in this.Employees)
            {
                writer.RenderBeginTag(HtmlTextWriterTag.P);
                writer.WriteEncodedText(string.Format("{0} {1}", person.GivenName, person.FamilyName));
                writer.RenderEndTag();
            }
        }
    }
}

The [ParseChildren(true)] attribute is needed so that at run time ASP.NET interprets the <Employees> tag as a property name rather than as literal markup to be rendered.

The [PersistChildren(false)] and [PersistenceMode(PersistenceMode.InnerProperty)] attributes are needed so that, if at design time you modify the Employees collection using the designer's Properties window, Visual Studio correctly persists the collection to markup.

Answer 2

I'm not sure exactly why you'd want to do this aside from academic reasons. Since some of the other posters have focused mainly on using controls to create your markup, why not use something like a DataSet to achieve what you're trying to achieve?

You would create a dataset by selecting DataSet from Add > New Item > Data >DataSet from the context menu. DataSets can be Strongly-Typed and provide you full Intellisense features, but this might not be ideal for your scenario. Just thought I'd throw this idea out there.

Using DataSets:

Process: Create a DataSet, create a DataTable, create columns (DataColumns) for the DataTable, instantiate and bind to a given .aspx control.

Standard DataSet/DataTable/DataColumn:

DataSet ds = new DataSet("MyDataSetNameSpace");
DataTable person = new DataTable();
//add columns to the datatable
person.Columns.Add(new DataColumn(typeof(string)), "FamilyName");
person.Columns.Add(new DataColumn(typeof(string)), "GivenName");

Strongly-Typed DataSet:

PersonDataSet personDs = new PersonDataSet("PersonDataSetNameSpace");
//DataTable should already exist in your strongly-typed DataSet because you define the datatables in the vs designer
//accessing the datatable
personDs.Person person = new PersonDataSet.Person();
person.GivenName = "John Eisenhower Smith";
person.FamilyName = "Johnny";//nickname?  I'm guessing this might actually be Smith

If you wanted to use the DataSet in Markup, you would bind it to the specific list control you are trying to create a list with.

//you can define the DataSource in Markup or in CodeBehind.  You'd have to define a protected or public variable so that you can access the item in your markup.
//In markup, you would set DataSource = <%# Person%>
myGridViewControl.DataBind();//bind the dataset/datatable to the control

MSDN Reference:

https://msdn.microsoft.com/en-us/library/ss7fbaez(v=vs.110).aspx

EDIT:

To accomplish what you accomplish with XAML, you'd have to inject XAML through the use of a Silverlight control. See this post for more information on how to do that:

Is there a way to insert Silverlight XAML into my page using ASP.NET code-behind?

The short answer is in WebForms, it can't be done at the moment. You'd have to accomplish this with hacks because the framework doesn't support it. You could use a C# code block to do what you're trying to do, but you still won't be able to accomplish what you are trying to accomplish correctly.

Answer 3

Can't you make Person as a user control? And add it as such:

<uc1:EmployeesViewer runat="server">
    <Employees>
        <uc1:Person GivenName="John"/>
    </Employees>
<uc1:EmployeesViewer/>

EDIT

Made a test example. Add the following to employeesView to be able to access persons in markup:

Private _emptyDataTemplate As New List(Of Person)
    <Browsable(False)>
    <PersistenceMode(PersistenceMode.InnerProperty)>
    <TemplateContainer(GetType(Person))>
    Public ReadOnly Property Persons() As List(Of Person)
        Get
            Return _emptyDataTemplate
        End Get
    End Property

Made a Person class:

Public Class Person
    Inherits System.Web.UI.UserControl

    Private msFirstName As String
    Public Property FirstName() As String
        Get
            Return msFirstName
        End Get
        Set(ByVal value As String)
            msFirstName = value
        End Set
    End Property
End Class

And in main.aspx I added this to markup:

<!-- top of page -->
<%@ Register TagPrefix="pd" TagName="Person" Src="Person.ascx" %>
<%@ Register TagPrefix="pd" TagName="pView" Src="WebUserControl1.ascx" %>

<!-- wherever you use employeesView -->
<pd:EmployeesView ID="PView1" runat="server">
    <Persons>
        <pd:Person ID="Person2" FirstName="blabal" runat="server"></pd:Person>
        <pd:Person ID="Person3" FirstName="bobba" runat="server"></pd:Person>
    </Persons>
</pd:EmployeesView>

Hope it helps : )

Answer 4

Yes, it is possible.

<% Person person1 = new Person();
   person1.FamiliName="Brown";
   person1.GivenName="John";
   List<Person> persons = new List<Person>();
   persons.Add(person1);
   EmployeesViewer.DataSource = persons;
%>

Answer 5

This is possible. However, it is entirely its own animal. While the approach is all Microsoft, it's surprising well adopted.

You can use xsd style sheets to format the data. Then you plug in an object, and it renders that object. In some versions of visual studio, there are even methods of generating the object models from the style sheet.

GL