• Status: Solved
  • Priority: Medium
  • Security: Public
  • Views: 205
  • Last Modified:

Need to fix the following class for asp.net 3.5 standards.

Need help to fix the following asp.net 3.5 standards
using System;
using System.Text;
using System.Xml;
using System.Collections;
using System.Diagnostics;
using System.Data;
using System.Data.SqlClient;
using System.Data.SqlTypes;
using System.Reflection;
using System.Xml.Serialization;
using System.IO;
using System.Collections.Generic;
using DataTransfer.Tables;
 
 
namespace DataTransfer.Tables
{
 
                [XmlType(Namespace = "urn:DataObjects")]
                [XmlRoot(Namespace = "urn:DataObjects")]
                [Serializable]
                public class tbl_tickets : DataTransfer.Tables.ColumnInfo
                {
 
                                private int ticketID = 0;
                                private string ticketNumber = "";
                                private string ticketType = "";
                                private string ticketStatus = "";
                                private string ticketSeverity = "";
                                private string shortDescription = "";
                                private string externalTicket = "";
                                private string reasonMenu = "";
                                private string problemNote = "";
                                private string solutionNote = "";
                                private string actionNote = "";
                                private string followupNote = "";
                                private bool companiesFlag = false;
                                private string agentCreated = "";
                                private DateTime dateCreated = System.DateTime.Now;
                                private DateTime dateLastModified = System.DateTime.Now;
                                private string agentClosed = "";
                                private DateTime dateClosed = System.DateTime.Now;
                                private string agentFollowup = "";
                                private DateTime followupBy = System.DateTime.Now;
                                private bool deletedFlag = false;
                                private string ticketTypeOld = "";
                                private string assignedTo = "";
                                private string requestType = "";
                                private string serviceImpact = "";
                                private DateTime dateTimeAssigned = System.DateTime.Now;
                                private string priority = "";
                                private DateTime dateAssigned = System.DateTime.Now;
                                private string trackIt = "";
                                private string contactMethod = "";
                                private string locationSIMs = "";
                                private string userID = "";
                                private string ticketApplicationType = "";
                                private int accountID = 0;
 
 
                                ///<summary>
                                ///Required = true
                                ///</summary>
                                [ColumnAttributes("TicketID",true,"int")]
                                public int TicketID
                                {
                                                 get
                                                 {
                                                    return ticketID;
                                                 }
                                                 set
                                                 {
                                                    if (value != ticketID)
                                                    {
                                                      ticketID = value;
                                                      this.IsDirty = true;
                                                    }
                                                 }
                                }
 
                                ///<summary>
                                ///Required = false
                                ///</summary>
                                [ColumnAttributes("TicketNumber",false,"string")]
                                public string TicketNumber
                                {
                                                 get
                                                 {
                                                    return ticketNumber;
                                                 }
                                                 set
                                                 {
                                                    string valueTrimmed = value.Trim();

                                                    if (valueTrimmed != ticketNumber)
                                                    {
                                                      ticketNumber = valueTrimmed;
                                                      this.IsDirty = true;
                                                    }
                                                 }
                                }
 
                                ///<summary>
                                ///Required = false
                                ///</summary>
                                [ColumnAttributes("TicketType",false,"string")]
                                public string TicketType
                                {
                                                 get
                                                 {
                                                    return ticketType;
                                                 }
                                                 set
                                                 {
                                                    string valueTrimmed = value.Trim();

                                                    if (valueTrimmed != ticketType)
                                                    {
                                                      ticketType = valueTrimmed;
                                                      this.IsDirty = true;
                                                    }
                                                 }
                                }
 
                                ///<summary>
                                ///Required = false
                                ///</summary>
                                [ColumnAttributes("TicketStatus",false,"string")]
                                public string TicketStatus
                                {
                                                 get
                                                 {
                                                    return ticketStatus;
                                                 }
                                                 set
                                                 {
                                                    string valueTrimmed = value.Trim();

                                                    if (valueTrimmed != ticketStatus)
                                                    {
                                                      ticketStatus = valueTrimmed;
                                                      this.IsDirty = true;
                                                    }
                                                 }
                                }
 
                                ///<summary>
                                ///Required = false
                                ///</summary>
                                [ColumnAttributes("TicketSeverity",false,"string")]
                                public string TicketSeverity
                                {
                                                 get
                                                 {
                                                    return ticketSeverity;
                                                 }
                                                 set
                                                 {
                                                    string valueTrimmed = value.Trim();

                                                    if (valueTrimmed != ticketSeverity)
                                                    {
                                                      ticketSeverity = valueTrimmed;
                                                      this.IsDirty = true;
                                                    }
                                                 }
                                }
 
                                ///<summary>
                                ///Required = false
                                ///</summary>
                                [ColumnAttributes("ShortDescription",false,"string")]
                                public string ShortDescription
                                {
                                                 get
                                                 {
                                                    return shortDescription;
                                                 }
                                                 set
                                                 {
                                                    string valueTrimmed = value.Trim();

                                                    if (valueTrimmed != shortDescription)
                                                    {
                                                      shortDescription = valueTrimmed;
                                                      this.IsDirty = true;
                                                    }
                                                 }
                                }
 
                                ///<summary>
                                ///Required = false
                                ///</summary>
                                [ColumnAttributes("ExternalTicket",false,"string")]
                                public string ExternalTicket
                                {
                                                 get
                                                 {
                                                    return externalTicket;
                                                 }
                                                 set
                                                 {
                                                    string valueTrimmed = value.Trim();

                                                    if (valueTrimmed != externalTicket)
                                                    {
                                                      externalTicket = valueTrimmed;
                                                      this.IsDirty = true;
                                                    }
                                                 }
                                }
 
                                ///<summary>
                                ///Required = false
                                ///</summary>
                                [ColumnAttributes("ReasonMenu",false,"string")]
                                public string ReasonMenu
                                {
                                                 get
                                                 {
                                                    return reasonMenu;
                                                 }
                                                 set
                                                 {
                                                    string valueTrimmed = value.Trim();

                                                    if (valueTrimmed != reasonMenu)
                                                    {
                                                      reasonMenu = valueTrimmed;
                                                      this.IsDirty = true;
                                                    }
                                                 }
                                }
 
                                ///<summary>
                                ///Required = false
                                ///</summary>
                                [ColumnAttributes("ProblemNote",false,"string")]
                                public string ProblemNote
                                {
                                                 get
                                                 {
                                                    return problemNote;
                                                 }
                                                 set
                                                 {
                                                    string valueTrimmed = value.Trim();

                                                    if (valueTrimmed != problemNote)
                                                    {
                                                      problemNote = valueTrimmed;
                                                      this.IsDirty = true;
                                                    }
                                                 }
                                }
 
                                ///<summary>
                                ///Required = false
                                ///</summary>
                                [ColumnAttributes("SolutionNote",false,"string")]
                                public string SolutionNote
                                {
                                                 get
                                                 {
                                                    return solutionNote;
                                                 }
                                                 set
                                                 {
                                                    string valueTrimmed = value.Trim();

                                                    if (valueTrimmed != solutionNote)
                                                    {
                                                      solutionNote = valueTrimmed;
                                                      this.IsDirty = true;
                                                    }
                                                 }
                                }
 
                                ///<summary>
                                ///Required = false
                                ///</summary>
                                [ColumnAttributes("ActionNote",false,"string")]
                                public string ActionNote
                                {
                                                 get
                                                 {
                                                    return actionNote;
                                                 }
                                                 set
                                                 {
                                                    string valueTrimmed = value.Trim();

                                                    if (valueTrimmed != actionNote)
                                                    {
                                                      actionNote = valueTrimmed;
                                                      this.IsDirty = true;
                                                    }
                                                 }
                                }
 
                                ///<summary>
                                ///Required = false
                                ///</summary>
                                [ColumnAttributes("FollowupNote",false,"string")]
                                public string FollowupNote
                                {
                                                 get
                                                 {
                                                    return followupNote;
                                                 }
                                                 set
                                                 {
                                                    string valueTrimmed = value.Trim();

                                                    if (valueTrimmed != followupNote)
                                                    {
                                                      followupNote = valueTrimmed;
                                                      this.IsDirty = true;
                                                    }
                                                 }
                                }
 
                                ///<summary>
                                ///Required = false
                                ///</summary>
                                [ColumnAttributes("CompaniesFlag",false,"bool")]
                                public bool CompaniesFlag
                                {
                                                 get
                                                 {
                                                    return companiesFlag;
                                                 }
                                                 set
                                                 {
                                                    if (value != companiesFlag)
                                                    {
                                                      companiesFlag = value;
                                                      this.IsDirty = true;
                                                    }
                                                 }
                                }
 
                                ///<summary>
                                ///Required = false
                                ///</summary>
                                [ColumnAttributes("AgentCreated",false,"string")]
                                public string AgentCreated
                                {
                                                 get
                                                 {
                                                    return agentCreated;
                                                 }
                                                 set
                                                 {
                                                    string valueTrimmed = value.Trim();

                                                    if (valueTrimmed != agentCreated)
                                                    {
                                                      agentCreated = valueTrimmed;
                                                      this.IsDirty = true;
                                                    }
                                                 }
                                }
 
                                ///<summary>
                                ///Required = false
                                ///</summary>
                                [ColumnAttributes("DateCreated",false,"DateTime")]
                                public DateTime DateCreated
                                {
                                                 get
                                                 {
                                                    return dateCreated;
                                                 }
                                                 set
                                                 {
                                                    if (value != dateCreated)
                                                    {
                                                      dateCreated = value;
                                                      this.IsDirty = true;
                                                    }
                                                 }
                                }
 
                                ///<summary>
                                ///Required = false
                                ///</summary>
                                [ColumnAttributes("DateLastModified",false,"DateTime")]
                                public DateTime DateLastModified
                                {
                                                 get
                                                 {
                                                    return dateLastModified;
                                                 }
                                                 set
                                                 {
                                                    if (value != dateLastModified)
                                                    {
                                                      dateLastModified = value;
                                                      this.IsDirty = true;
                                                    }
                                                 }
                                }
 
                                ///<summary>
                                ///Required = false
                                ///</summary>
                                [ColumnAttributes("AgentClosed",false,"string")]
                                public string AgentClosed
                                {
                                                 get
                                                 {
                                                    return agentClosed;
                                                 }
                                                 set
                                                 {
                                                    string valueTrimmed = value.Trim();

                                                    if (valueTrimmed != agentClosed)
                                                    {
                                                      agentClosed = valueTrimmed;
                                                      this.IsDirty = true;
                                                    }
                                                 }
                                }
 
                                ///<summary>
                                ///Required = false
                                ///</summary>
                                [ColumnAttributes("DateClosed",false,"DateTime")]
                                public DateTime DateClosed
                                {
                                                 get
                                                 {
                                                    return dateClosed;
                                                 }
                                                 set
                                                 {
                                                    if (value != dateClosed)
                                                    {
                                                      dateClosed = value;
                                                      this.IsDirty = true;
                                                    }
                                                 }
                                }
 
                                ///<summary>
                                ///Required = false
                                ///</summary>
                                [ColumnAttributes("AgentFollowup",false,"string")]
                                public string AgentFollowup
                                {
                                                 get
                                                 {
                                                    return agentFollowup;
                                                 }
                                                 set
                                                 {
                                                    string valueTrimmed = value.Trim();

                                                    if (valueTrimmed != agentFollowup)
                                                    {
                                                      agentFollowup = valueTrimmed;
                                                      this.IsDirty = true;
                                                    }
                                                 }
                                }
 
                                ///<summary>
                                ///Required = false
                                ///</summary>
                                [ColumnAttributes("FollowupBy",false,"DateTime")]
                                public DateTime FollowupBy
                                {
                                                 get
                                                 {
                                                    return followupBy;
                                                 }
                                                 set
                                                 {
                                                    if (value != followupBy)
                                                    {
                                                      followupBy = value;
                                                      this.IsDirty = true;
                                                    }
                                                 }
                                }
 
                                ///<summary>
                                ///Required = false
                                ///</summary>
                                [ColumnAttributes("DeletedFlag",false,"bool")]
                                public bool DeletedFlag
                                {
                                                 get
                                                 {
                                                    return deletedFlag;
                                                 }
                                                 set
                                                 {
                                                    if (value != deletedFlag)
                                                    {
                                                      deletedFlag = value;
                                                      this.IsDirty = true;
                                                    }
                                                 }
                                }
 
                                ///<summary>
                                ///Required = false
                                ///</summary>
                                [ColumnAttributes("TicketTypeOld",false,"string")]
                                public string TicketTypeOld
                                {
                                                 get
                                                 {
                                                    return ticketTypeOld;
                                                 }
                                                 set
                                                 {
                                                    string valueTrimmed = value.Trim();

                                                    if (valueTrimmed != ticketTypeOld)
                                                    {
                                                      ticketTypeOld = valueTrimmed;
                                                      this.IsDirty = true;
                                                    }
                                                 }
                                }
 
                                ///<summary>
                                ///Required = false
                                ///</summary>
                                [ColumnAttributes("AssignedTo",false,"string")]
                                public string AssignedTo
                                {
                                                 get
                                                 {
                                                    return assignedTo;
                                                 }
                                                 set
                                                 {
                                                    string valueTrimmed = value.Trim();

                                                    if (valueTrimmed != assignedTo)
                                                    {
                                                      assignedTo = valueTrimmed;
                                                      this.IsDirty = true;
                                                    }
                                                 }
                                }
 
                                ///<summary>
                                ///Required = false
                                ///</summary>
                                [ColumnAttributes("RequestType",false,"string")]
                                public string RequestType
                                {
                                                 get
                                                 {
                                                    return requestType;
                                                 }
                                                 set
                                                 {
                                                    string valueTrimmed = value.Trim();

                                                    if (valueTrimmed != requestType)
                                                    {
                                                      requestType = valueTrimmed;
                                                      this.IsDirty = true;
                                                    }
                                                 }
                                }
 
                                ///<summary>
                                ///Required = false
                                ///</summary>
                                [ColumnAttributes("ServiceImpact",false,"string")]
                                public string ServiceImpact
                                {
                                                 get
                                                 {
                                                    return serviceImpact;
                                                 }
                                                 set
                                                 {
                                                    string valueTrimmed = value.Trim();

                                                    if (valueTrimmed != serviceImpact)
                                                    {
                                                      serviceImpact = valueTrimmed;
                                                      this.IsDirty = true;
                                                    }
                                                 }
                                }
 
                                ///<summary>
                                ///Required = false
                                ///</summary>
                                [ColumnAttributes("DateTimeAssigned",false,"DateTime")]
                                public DateTime DateTimeAssigned
                                {
                                                 get
                                                 {
                                                    return dateTimeAssigned;
                                                 }
                                                 set
                                                 {
                                                    if (value != dateTimeAssigned)
                                                    {
                                                      dateTimeAssigned = value;
                                                      this.IsDirty = true;
                                                    }
                                                 }
                                }
 
                                ///<summary>
                                ///Required = false
                                ///</summary>
                                [ColumnAttributes("Priority",false,"string")]
                                public string Priority
                                {
                                                 get
                                                 {
                                                    return priority;
                                                 }
                                                 set
                                                 {
                                                    string valueTrimmed = value.Trim();

                                                    if (valueTrimmed != priority)
                                                    {
                                                      priority = valueTrimmed;
                                                      this.IsDirty = true;
                                                    }
                                                 }
                                }
 
                                ///<summary>
                                ///Required = false
                                ///</summary>
                                [ColumnAttributes("DateAssigned",false,"DateTime")]
                                public DateTime DateAssigned
                                {
                                                 get
                                                 {
                                                    return dateAssigned;
                                                 }
                                                 set
                                                 {
                                                    if (value != dateAssigned)
                                                    {
                                                      dateAssigned = value;
                                                      this.IsDirty = true;
                                                    }
                                                 }
                                }
 
                                ///<summary>
                                ///Required = false
                                ///</summary>
                                [ColumnAttributes("TrackIt",false,"string")]
                                public string TrackIt
                                {
                                                 get
                                                 {
                                                    return trackIt;
                                                 }
                                                 set
                                                 {
                                                    string valueTrimmed = value.Trim();

                                                    if (valueTrimmed != trackIt)
                                                    {
                                                      trackIt = valueTrimmed;
                                                      this.IsDirty = true;
                                                    }
                                                 }
                                }
 
                                ///<summary>
                                ///Required = false
                                ///</summary>
                                [ColumnAttributes("ContactMethod",false,"string")]
                                public string ContactMethod
                                {
                                                 get
                                                 {
                                                    return contactMethod;
                                                 }
                                                 set
                                                 {
                                                    string valueTrimmed = value.Trim();

                                                    if (valueTrimmed != contactMethod)
                                                    {
                                                      contactMethod = valueTrimmed;
                                                      this.IsDirty = true;
                                                    }
                                                 }
                                }
 
                                ///<summary>
                                ///Required = false
                                ///</summary>
                                [ColumnAttributes("LocationSIMs",false,"string")]
                                public string LocationSIMs
                                {
                                                 get
                                                 {
                                                    return locationSIMs;
                                                 }
                                                 set
                                                 {
                                                    string valueTrimmed = value.Trim();

                                                    if (valueTrimmed != locationSIMs)
                                                    {
                                                      locationSIMs = valueTrimmed;
                                                      this.IsDirty = true;
                                                    }
                                                 }
                                }
 
                                ///<summary>
                                ///Required = false
                                ///</summary>
                                [ColumnAttributes("UserID",false,"string")]
                                public string UserID
                                {
                                                 get
                                                 {
                                                    return userID;
                                                 }
                                                 set
                                                 {
                                                    string valueTrimmed = value.Trim();

                                                    if (valueTrimmed != userID)
                                                    {
                                                      userID = valueTrimmed;
                                                      this.IsDirty = true;
                                                    }
                                                 }
                                }
 
                                ///<summary>
                                ///Required = false
                                ///</summary>
                                [ColumnAttributes("TicketApplicationType",false,"string")]
                                public string TicketApplicationType
                                {
                                                 get
                                                 {
                                                    return ticketApplicationType;
                                                 }
                                                 set
                                                 {
                                                    string valueTrimmed = value.Trim();

                                                    if (valueTrimmed != ticketApplicationType)
                                                    {
                                                      ticketApplicationType = valueTrimmed;
                                                      this.IsDirty = true;
                                                    }
                                                 }
                                }
 
                                ///<summary>
                                ///Required = false
                                ///</summary>
                                [ColumnAttributes("AccountID",false,"int")]
                                public int AccountID
                                {
                                                 get
                                                 {
                                                    return accountID;
                                                 }
                                                 set
                                                 {
                                                    if (value != accountID)
                                                    {
                                                      accountID = value;
                                                      this.IsDirty = true;
                                                    }
                                                 }
                                }
 
 
                }
 
}
0
mathieu_cupryk
Asked:
mathieu_cupryk
  • 8
  • 2
1 Solution
 
daveamourCommented:
You won't get any help unless you tell people what the problem is!
0
 
mathieu_cuprykAuthor Commented:
Hi Dave,

I need to build a class diagram in asp.net 3.5 visual studio. Can I use the server explorer and drag and drop the table. The correspond table can generate the class diagram as well as the class entity.
When I say class entity I mean the above example.
0
 
daveamourCommented:
Can you right click on the class in Visual Studio and click on View Class Diagram?
0
Concerto's Cloud Advisory Services

Want to avoid the missteps to gaining all the benefits of the cloud? Learn more about the different assessment options from our Cloud Advisory team.

 
mathieu_cuprykAuthor Commented:
This is what I have when I create the Ticket.edmx.

Now what I need is to generate the class from this?
I mean the attributes and their type and do a get and set

ticket.png
0
 
mathieu_cuprykAuthor Commented:
I right click on the ticket1.designer.cs and I can see the classdragram1.cd
Now I have the entity object from this I would like to produce the class.
0
 
mathieu_cuprykAuthor Commented:
I think I can do a right click on the image and do a create new class.

Now I have an empty file
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ClassLibrary
{
    public class Ticket
    {
    }
}
0
 
mathieu_cuprykAuthor Commented:
This is where I am stuck
I need to have the class with the definition of variables and the get and set
0
 
mathieu_cuprykAuthor Commented:
This is what I have now?
Where do i go from here.

emptyclass.gif
0
 
mathieu_cuprykAuthor Commented:
I want a class http://dotnetperls.com/Content/SqlClient-Tutorial.aspx
I need to create the ticket.cs like the following:

public class Dog
{
    public int Weight { get; set; }
    public string Name { get; set; }
    public string Breed { get; set; }
    public override string ToString()
    {
        return string.Format("Weight: {0}, Name: {1}, Breed: {2}",
            Weight, Name, Breed);
    }
}
0
 
mathieu_cuprykAuthor Commented:
anyhelp
0
 
Bob LearnedCommented:
It looks like you are helping yourself pretty well.  What kind of additional help are you looking for?
0

Featured Post

Free Tool: Port Scanner

Check which ports are open to the outside world. Helps make sure that your firewall rules are working as intended.

One of a set of tools we are providing to everyone as a way of saying thank you for being a part of the community.

  • 8
  • 2
Tackle projects and never again get stuck behind a technical roadblock.
Join Now