Silverlight talking to a WCF using RIA Services Silverlight Client

Question

My silverlight project has references to the RIA Services Silverlight Client and my .web application has access to RIAServices.Server.

I can't seem to find a good tutorial to learn how to connect these. Once I understand how to get the data from my NumberGenerator method. I can pick it up from there. I have three questions that I need some help with.

First, am I setting up this project correctly? I never done a project with RIA before.

Secondly what reference do I need to use ServiceContract(), FaultContract, and OperationContract? Most examples show that they are in the System.ServiceModel library. In this case with using the external library RIA Services Silverlight Client that is not the case. It throws a error saying I am missing a reference. What other libraries would have those three in it?

My last question is what URI do you use in the SystemDomainContext? Where I found the code at used this MyFirstRIAApplication-Web-EmployeeDomainService.svc but in my case I don't have anything that has a .svc extension. Would I use the .xap or .aspx?

Here is my Silverlight code

Here is my NumberGenerator Silverlight UserControl Page Code

public partial class NumberGenerator : UserControl
{
    public NumberGenerator()
    {
       InitializeComponent();
       GenerateNumber();
     }

    private void GenerateButton_Click(object sender, RoutedEventArgs e)
    {
        GenerateNumber();
    }

    private void GenerateNumber()
    {
       int result = 0 
       SystemClientServices systemclientservices = SystemClientServices.Instance;
       result = systemclientservices.GenerateNumber();
       NumberLabel.Content = result;
    }
} 

Here is my System Client Services class

private readonly static SystemClientServices _instance = new SystemClientServices();

private SystemDomainContext _domainContext = new SystemDomainContext();

private SystemClientServices() { }

public static SystemClientServices Instance
{
    get
    {
        return _instance;
    }
}

public int GenerateNumber()
{
    //Code goes here to get the information from the Domainservices
    LoadOperation load = this._domainContext.Load(this._domainContext.GetNumberGeneratorQuery(), LoadBehavior.KeepCurrent, false);
    return Convert.ToInt32(load.Entities);
}

Here is my NumberGenerator class on the silverlight local project

 public sealed partial class NumberGenerator : Entity
 {
    private static readonly NumberGenerator _instance = new NumberGenerator();
    public int NumberGenerated { get; set; }

    public NumberGenerator()
    {
        NumberGenerated = 0;
    }

    public static NumberGenerator Instance
    {
        get
        {
            return _instance;
        }
    }
 }

Here is System Domain Conext class on the silverlight local project

 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
 using System.ComponentModel.DataAnnotations;
 using System.Linq;
 using System.Runtime.Serialization;
 using System.ServiceModel.DomainServices;
 using System.ServiceModel.DomainServices.Client;
 using System.ServiceModel.DomainServices.Client.ApplicationServices;
 using System.ServiceModel.Web;
 using System.ServiceModel;
 public sealed partial class SystemDomainConext : DomainContext
 {
    #region Extensibility Method Definitions

    /// <summary>
    /// This method is invoked from the constructor once initialization is complete and
    /// can be used for further object setup.
    /// </summary>
    partial void OnCreated();

    #endregion


    /// <summary>
    /// Initializes a new instance of the <see cref="EmployeeDomainContext"/> class.
    /// </summary>
    public SystemDomainConext() : this(new WebDomainClient<ISystemDomainServiceContract>(new Uri("MyFirstRIAApplication-Web-EmployeeDomainService.svc", UriKind.Relative)))
    {
    }

    /// <summary>
    /// Initializes a new instance of the <see cref="EmployeeDomainContext"/> class with the specified service URI.
    /// </summary>
    /// <param name="serviceUri">The EmployeeDomainService service URI.</param>
    public SystemDomainConext(Uri serviceUri) : this(new WebDomainClient<ISystemDomainServiceContract>(serviceUri))
    {
    }

    /// <summary>
    /// Initializes a new instance of the <see cref="EmployeeDomainContext"/> class with the specified <paramref name="domainClient"/>.
    /// </summary>
    /// <param name="domainClient">The DomainClient instance to use for this DomainContext.</param>
    public SystemDomainConext(DomainClient domainClient) : base(domainClient)
    {
        this.OnCreated();
    }

    /// <summary>
    /// Gets the set of <see cref="Employee"/> entity instances that have been loaded into this <see cref="EmployeeDomainContext"/> instance.
    /// </summary>
    public EntitySet<NumberGenerator> GeneratedNumber
    {
        get
        {
            return base.EntityContainer.GetEntitySet<NumberGenerator>();
        }
    }

    /// <summary>
    /// Gets an EntityQuery instance that can be used to load <see cref="Employee"/> entity instances using the 'GetEmployee' query.
    /// </summary>
    /// <returns>An EntityQuery that can be loaded to retrieve <see cref="Employee"/> entity instances.</returns>
    public EntityQuery<NumberGenerator> GetNumberGeneratorQuery()
    {
        this.ValidateMethod("GetGeneratedNumber", null);
        return base.CreateQuery<NumberGenerator>("GetNumberGenerator", null, false, true);
    }

    /// <summary>
    /// Creates a new EntityContainer for this DomainContext's EntitySets.
    /// </summary>
    /// <returns>A new container instance.</returns>
    protected override EntityContainer CreateEntityContainer()
    {
        return new NumberGeneratorDomainContextEntityContainer();
    }

    /// <summary>
    /// Service contract for the 'EmployeeDomainService' DomainService.
    /// </summary>
    [ServiceContract()]
    public interface ISystemDomainServiceContract
    {
        /// <summary>
        /// Asynchronously invokes the 'GetEmployee' operation.
        /// </summary>
        /// <param name="callback">Callback to invoke on completion.</param>
        /// <param name="asyncState">Optional state object.</param>
        /// <returns>An IAsyncResult that can be used to monitor the request.</returns>
        [FaultContract(typeof(DomainServiceFault), Action="http://tempuri.org/EmployeeDomainService/GetEmployeeDomainServiceFault", Name="DomainServiceFault", Namespace="DomainServices")]
        [OperationContract(AsyncPattern=true, Action="http://tempuri.org/EmployeeDomainService/GetEmployee", ReplyAction="http://tempuri.org/EmployeeDomainService/GetEmployeeResponse")]
        [WebGet()]
        IAsyncResult GetGeneratedNumber(AsyncCallback callback, object asyncState);

        /// <summary>
        /// Completes the asynchronous operation begun by 'BeginGetEmployee'.
        /// </summary>
        /// <param name="result">The IAsyncResult returned from 'BeginGetEmployee'.</param>
        /// <returns>The 'QueryResult' returned from the 'GetEmployee' operation.</returns>
        QueryResult<NumberGenerator> EndGetGeneratedNumber(IAsyncResult result);

        /// <summary>
        /// Asynchronously invokes the 'SubmitChanges' operation.
        /// </summary>
        /// <param name="changeSet">The change-set to submit.</param>
        /// <param name="callback">Callback to invoke on completion.</param>
        /// <param name="asyncState">Optional state object.</param>
        /// <returns>An IAsyncResult that can be used to monitor the request.</returns>
        [FaultContract(typeof(DomainServiceFault), Action="http://tempuri.org/EmployeeDomainService/SubmitChangesDomainServiceFault", Name="DomainServiceFault", Namespace="DomainServices")]
        [OperationContract(AsyncPattern=true, Action="http://tempuri.org/EmployeeDomainService/SubmitChanges", ReplyAction="http://tempuri.org/EmployeeDomainService/SubmitChangesResponse")]
        IAsyncResult BeginSubmitChanges(IEnumerable<ChangeSetEntry> changeSet, AsyncCallback callback, object asyncState);

        /// <summary>
        /// Completes the asynchronous operation begun by 'BeginSubmitChanges'.
        /// </summary>
        /// <param name="result">The IAsyncResult returned from 'BeginSubmitChanges'.</param>
        /// <returns>The collection of change-set entry elements returned from 'SubmitChanges'.</returns>
        IEnumerable<ChangeSetEntry> EndSubmitChanges(IAsyncResult result);
    }

    internal sealed class NumberGeneratorDomainContextEntityContainer : EntityContainer
    {

        public NumberGeneratorDomainContextEntityContainer()
        {
            this.CreateEntitySet<NumberGenerator>(EntitySetOperations.Edit);
        }
    }
}

Here is my System Domain Services class that is on the Silverlight.web

[EnableClientAccess()]
public class SystemDomainServices : DomainService
{
  private NumberGenerator numberGenerator = NumberGenerator.Instance;
  public int NumberGenerate()
  {
      return numberGenerator.NumberGenerated;
  }
}   

Here is the NumberGenerator class on the silverlight.web

private static readonly NumberGenerator _instance = new NumberGenerator();
[Key]
public int NumberGenerated { get; set; }

public NumberGenerator()
{
    NumberGenerated = GenerateNumber();
}

public static NumberGenerator Instance
{
    get
    {
        return _instance;
    }
}

public int GenerateNumber()
{
    string db_date = "";
    int db_num = 0;
    string todaysdate = "";
    int temp_num = db_num;
    int result = 0;
    using (SqlConnection connection = new SqlConnection(DBConnectionString))
    {
        connection.Open();
        using (SqlCommand command = new SqlCommand("SELECT * FROM table", connection))
        {
            using (SqlDataReader reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    db_date = reader.GetString(0);
                    db_num = (int)(reader.GetSqlInt32(1));
                    todaysdate = DateTime.Now.ToString("yMMdd");
                    temp_num = db_num;
                }
                reader.Close();
            }
            if (todaysdate != db_date)
            {
                using (SqlCommand dateUpate = new SqlCommand("UPDATE table SET tsDate='" + todaysdate + "' WHERE tsDate='" + db_date + "'", connection))
                {
                    dateUpate.ExecuteNonQuery();
                }
                db_num = 0;
                db_date = todaysdate;
            }
            db_num++;
            using (SqlCommand numUpate = new SqlCommand("UPDATE table SET tsNum='" + db_num + "' WHERE tsNum='" + temp_num + "'", connection))
            {
                numUpate.ExecuteNonQuery();
            }
            result = Convert.ToInt32(db_date + db_num.ToString().PadLeft(3, '0'));
            connection.Close();
            connection.Dispose();
        }
        return result;
    }
}

Answer 1

The answer to question two you might be have to go to Tools at the top, NuGet Package Manager, Package Management Console, and then type the following command to install the package for those three functions. PM> Install-Package RIAServices.Silverlight.DomainDataSource