none
datacontext gives nullreference exception RRS feed

  • Question

  • hey,

    When using submitchanges my DELETE gives a nullreference exception. This only occurs when using delete, my update and insert functions are fine. When i check the changeset it gives me a correct count on deletes.

    Are there some attributes needed in mapping used in the delete?

    This is the class i'm using to delete:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Data.Linq;
    using System.Linq.Expressions;
    using System.Reflection;
    using System.Data.Linq.Mapping;
    using System.Runtime.Serialization;
    using System.IO;
    using System.Xml.Serialization;
    using System.Xml;
    
    namespace DAL
    {
        public abstract class BaseRepository<T, TContextType>
            where T:class
            where TContextType: DataContext, new()
        {
            public BaseRepository()
            { }
    
            //abstract voor elke entiteit
            protected abstract Expression<Func<T, bool>> HaalID(int Id);
    
            //Laad functie dmv nummer
            public T Laad(int Id)
            {
                DataContext Context = MaakContext();
                return Laad(Id, Context);
            }
    
            //laad functie dmv nummer en aangeleverde datacontext
            public T Laad(int Id, DataContext context)
            {
                //wanneer Id null is zal er niks worden teruggeven
                if (Id == 0)
                    return null;
                else if (context == null)
                    return null;
                //Haal door middel van id 1 item op
                return HaalTabel(context).Single(HaalID(Id));
            }
    
            //Bewaar een object
            public T Opslaan(T entiteit)
            {
                return VoerUitOpDatabase(entiteit, "slaop", false);
            }
    
            //Bewaar een object met al zijn cild objecten
            public virtual T OpslaanRecursief(T entiteit)
            {
                return VoerUitOpDatabase(entiteit, "slaop", true);
            }
    
            //Verwijder een object
            public virtual T Verwijder(T Verwijderen)
            {
                return VoerUitOpDatabase(Verwijderen, "verwijder", false);
            }
    
            //Verwijder een object dmv een idnummer
            public T Verwijder(int Id)
            {
                return Verwijder(Laad(Id));
            }
    
            //Verwijder een object dmv een idnummer, hierbij worden ook childobjecten verwijderd
            public T VerwijderRecursief(int Id)
            {
                return VerwijderRecursief(Laad(Id));
            }
    
            //Verwijder een object met al zijn childobjecten 
            public virtual T VerwijderRecursief(T Verwijderen)
            {
                return VoerUitOpDatabase(Verwijderen, "verwijder", true);
            }
    
            //Haal een Context op
            protected virtual TContextType MaakContext()
            {
                //TODO: test met geen verbinding
                TContextType context;
                try
                {
                    context = new TContextType();
                    //Stel de Console in als output
                    context.Log = Console.Out;
                    return context;
                }
                catch (TargetInvocationException e)
                {
                    lastException = e;
                }
                return null;
            }
    
            //Haal een Tabel op van type T met een context
            protected Table<T> HaalTabel(DataContext context)
            {
                if (context == null)
                    return null;
                Table<T> test = default(Table<T>);
                try
                {
                    test = (Table<T>)context.GetTable(typeof(T));
                    //test = (Table<T>)MaakContext().GetTable(typeof(T));
                }
                catch (InvalidOperationException ex)
                {
                    Console.WriteLine(ex.Message);
                }
                return test;
            }
    
            //Voer een actie uit op de Database
            private T VoerUitOpDatabase(T entiteit, string mode, bool recursief)
            {
                using (DataContext context = MaakContext())
                {
                    T detachedentiteit = default(T);
                    try
                    {
                        detachedentiteit = EntityDetacher<T>.Detach(entiteit);
                        Table<T> tabel = HaalTabel(context);
    
                        if (mode == "verwijder")
                        {
                            //zonder aan de datacontext te zitten kan een object niet verwijderd worden
                            tabel.Attach(detachedentiteit);
                        }
    
                        IterateEntity(detachedentiteit, context, tabel, mode, recursief);
    
                        VoegWijzigingenToe(context);
    
                        //update de Id van een object
                        
                        if (mode == "slaop")
                        {
                            PropertyInfo IDPropertyInfo =
                                entiteit.GetType().GetProperty(
                                    context.Mapping.GetTable(typeof(T)).RowType.IdentityMembers[0].Name);
                            IDPropertyInfo.SetValue(entiteit, IDPropertyInfo.GetValue(detachedentiteit, null), null);
                        }
                    }
                    catch (System.Data.SqlClient.SqlException e)
                    {
                        SetException(e, context);
                    }
                    catch (Exception ex)
                    {
                        SetException(ex, context);
                    }
                    return detachedentiteit;
                }
            }
    
            //Voer wijzigingen uit die op een datacontext staan
            private void VoegWijzigingenToe(DataContext context)
            {
                try
                {
                    context.Connection.Open();
                    ChangeSet test = context.GetChangeSet();
                    context.SubmitChanges(ConflictMode.ContinueOnConflict);
                }
                catch (ChangeConflictException e)
                {
                    Console.WriteLine("Optimistic concurrency error.");
                    Console.WriteLine(e.Message);
                    Console.ReadLine();
                    foreach (ObjectChangeConflict occ in context.ChangeConflicts)
                    {
                        MetaTable metatable = context.Mapping.GetTable(occ.Object.GetType());
                        T entityInConflict = (T)occ.Object;
                        Console.WriteLine("Table name: {0}", metatable.TableName);
                        Console.Write("Customer ID: ");
                        //Console.WriteLine(entityInConflict.CustomerID);
                        foreach (MemberChangeConflict mcc in occ.MemberConflicts)
                        {
                            object currVal = mcc.CurrentValue;
                            object origVal = mcc.OriginalValue;
                            object databaseVal = mcc.DatabaseValue;
                            MemberInfo mi = mcc.Member;
                            Console.WriteLine("Member: {0}", mi.Name);
                            Console.WriteLine("current value: {0}", currVal);
                            Console.WriteLine("original value: {0}", origVal);
                            Console.WriteLine("database value: {0}", databaseVal);
                        }
                    }
                }
    
            }
    
            //Itereer langs alle objecten van een Set(entiteitenSet)
            internal void IterateEntitySet(object Set, DataContext context, string mode, bool recursief)
            {
                //Haal tabel op
                Table<T> tabel = HaalTabel(context);
                foreach (T VolgendeEntiteit in (EntitySet<T>)Set)
                {
                    IterateEntity(VolgendeEntiteit, context, tabel, mode, recursief);
                }
            }
    
            //Itereer door alle properties
            private void IterateEntity(T entiteit, DataContext context, Table<T> tabel, string mode, bool recursief)
            {
                //Sla alle gevonden associaties ook op?
                if (recursief)
                {
                    //vind alle associaties
                    foreach (MetaAssociation association in context.Mapping.GetMetaType(typeof(T)).Associations)
                    {
                        //Controleer of het een associatie is
                        if (association.IsMany && association.ThisKeyIsPrimaryKey)
                        {
                            PropertyInfo AssociationProperty = entiteit.GetType().GetProperty(association.ThisMember.Name);
                            //Controleer of er iets in de set zit
                            if (AssociationProperty.PropertyType.Name == "EntitySet`1")
                            {
                                //bewaar de set
                                try
                                {
                                    //Zoek bijbehorende repository op
                                    object Repository = association.OtherType.Type.GetMethod("CreateRepository").Invoke(null, null);
                                    //Voer methode uit om entiteiten uit set op te slaan
                                    Repository.GetType().GetMethod("IterateEntitySet",
                                                                 BindingFlags.NonPublic | BindingFlags.Instance).Invoke(
                                        Repository,
                                        new object[4]
                                        {
                                            AssociationProperty.GetValue(entiteit, null),
                                            context,
                                            mode,
                                            recursief
                                        }
                                        );
                                }
                                //Fout wanneer het object geen methode heeft genaamd CreateRepository
                                catch (System.Reflection.TargetInvocationException e)
                                {
                                    SetException(e, context);
                                }
                            }
                        }
                    }
                }
    
                switch (mode)
                {
                    case "slaop":
                        if (IsNieuw(entiteit, context))
                        {
                            tabel.InsertOnSubmit(entiteit);
                        }
                        else
                        {
                            HaalTabel(context).Attach(entiteit);
                            context.Refresh(RefreshMode.KeepCurrentValues, entiteit);
                        }
                        break;
                    case "verwijder":
                        context.Refresh(RefreshMode.KeepChanges, entiteit);
                        //HaalTabel(context).Attach(entiteit);
                        HaalTabel(context).DeleteOnSubmit(entiteit);
                        break;
                }
            }
    
            //Controleer of het object nieuw is of niet
            private bool IsNieuw(T entiteit, DataContext context)
            {
                return (int)entiteit.GetType().GetProperty(context.Mapping.GetTable(typeof(T)).RowType.IdentityMembers[0].Name).GetValue(entiteit, null) == 0;
            }
    
            private Exception lastException;
    
            //functie die de laatste exception bijhoud
            private void SetException(Exception Exception, DataContext context)
            {
                lastException = Exception;
                if (lastException != null)
                {
                    context.Log.Write(Exception.Message);
                }
            }
    
            //Haal de laatst gemaakte exception op
            public Exception HaalException()
            {
                if (this.lastException != null)
                    return this.lastException;
                else
                    return null;
            }
        }
    }
    

    TIA,

    Monday, April 12, 2010 1:39 PM