Wie übernimmt SP 2013 individuelle Felder aus den AfterProperties richtig?

Remei erstellt 27 März 2013 16:11

Sehr geehrte Forenbesucher,

jeder kennt es, Ihr nhabt etwas in SP 2010 entwickelt und wollt es mit dem SP 2013 konsolidieren. Beim genaueren Test fällt auf ein individuelles Feld dessen internen Namen Ihr kennt , wird bei einem ItemAdding Event nicht gesetzt. Das gemeine an der Sache Ihr habt den Wert in die AfterProperties gesetzt und trotzdem wird er nicht ünernommen. Das stellt man beim Debuggen fest. Im SharePoint 2010 funktioniert die Solution.

Das individuelle Feld Händler soll gesetzt werden mit dem Wert aus dem überliegenden Ordner per ItemAdding Event.

Hier der Code und meine Frage, wie mache ich das richtig, sodass das Feld wie im SharePoint 2010 befüllt wird?

namespace EventReceiverProject4.EventReceiver1
{
    /// <summary>
    /// List Item Events
    /// </summary>
    public class EventReceiver1 : SPItemEventReceiver
    {
        /// <summary>
        /// An item is being added.
        /// </summary>
        public override void ItemAdding(SPItemEventProperties properties)
        {
            base.ItemAdding(properties);
            ///Web http://www.sharepoint-tips.com/2006/08/bad-news-synchronous-list-events-bug.html
            String[] ordnerPfad = null; //properties.AfterUrl zertrennt bei "/"
            String relativerPfad = "/"; //relativer Pfad zum Ordner innerhalb eienr SharePoint Bibliothek
            SPFolder ordner = null; // Ordner darüberliegender Ordner zum Element
            String[] inhaltstypFeldnamen = null; //Feldnamen des Inhaltstypen
            String standardInhaltstypName = null; //Standardinhaltyp der DokumentBibliothek
            SPContentType inhaltstyp = null; //Ordner-Inhaltstyp
            SPContentType standardInhaltstyp = null; //Standard-Inhaltstype der DokumentBibliothek
            SPFieldCollection inhaltstypFelder = null; //Feldnamen des Ordnerinhaltypstypen

            //zunächst begrenzt auf die EventdokumentBibliothek
            if (String.Equals(properties.Web.Lists[properties.ListId].Title, "Eventdokument"))
            {
                ///*********** folgender Code beschafft den Ordner *****************
                ordnerPfad = properties.AfterUrl.Split('/');

                //erstellt den relativen Ordnerpfad
                //z.B. /Eventdokument/SLM/
                for (int i = 0; i < ordnerPfad.Length - 1; i++)
                {
                    relativerPfad += ordnerPfad[i] + "/";
                }

                //den Ordner abgesichert versuchen zu bekommen
                try
                {
                    ordner = properties.Web.GetFolder(relativerPfad);
                }
                catch (SPException fehler)
                {
                    //eventuell nachträglich eigene Fehlerseite erbauen
                }

                ///********* (Ordner) Inhaltstyp mit Feldnamen beschaffen
                if (ordner.Exists) //nur betreten, falls der Ordner existiert
                {
                    //Inhaltstyp des Ordners und die Feld auslesen
                    // diese in Strings speichern
                    //es wird davon ausgegangen ContentTypesEnabled = true !
                    inhaltstyp = ordner.Item.ContentType;
                    inhaltstypFelder = ordner.Item.ContentType.Fields;
                    inhaltstypFeldnamen = new String[inhaltstypFelder.Count];

                    //Standardinhaltstyp auslesen und dessen Feldnamen
                    standardInhaltstypName = properties.List.ContentTypes[0].Name.ToString();

                    ///interne Feldnamen holen aus dem Ordner-Inhaltstypen
                    for (int i = 0; i < inhaltstypFelder.Count; i++)
                    {
                        inhaltstypFeldnamen[i] = inhaltstypFelder[i].InternalName;
                    }

                    ///************** eventuelle Erweiterung: Standardinhaltstyp besorgen *************
                    ///über SPFolder-Klasse nutzt man die Eigenschaft ContentTypeOrder
                    ///Diese Kollektion enthält an erster Stelle den Standard Inhaltstyp.
                    ///Auf den Wurzel-Ordner greife ich zu, weil dort ganz sicher eine
                    ///Inhaltstyp-Nummerierung vorliegt.

                    //erwünschte AfterProperties Felder befüllen und
                    //Felder befüllen die im Standard-Inhaltstypen vorkommen
                    for (int i = 0; i < inhaltstypFeldnamen.Length; i++)
                    {
                        if (i == 0) properties.AfterProperties[inhaltstypFeldnamen[i]] = standardInhaltstypName;
                        else properties.AfterProperties[inhaltstypFeldnamen[i]] = ordner.Item[inhaltstypFeldnamen[i]];
                        //properties.AfterProperties["vti_title"] = "Remywashere";
                        //properties.AfterProperties["H_x00e4_ndler"] = "Remywashere";
                    }
                }
            }

        }

        /// <summary>
        /// An item is being updated.
        /// </summary>
        public override void ItemUpdating(SPItemEventProperties properties)
        {
            base.ItemUpdating(properties);
        }

        /// <summary>
        /// An item is being deleted.
        /// </summary>
        public override void ItemDeleting(SPItemEventProperties properties)
        {
            base.ItemDeleting(properties);
        }

        /// <summary>
        /// An item is being checked in.
        /// </summary>
        public override void ItemCheckingIn(SPItemEventProperties properties)
        {
            base.ItemCheckingIn(properties);
        }

        /// <summary>
        /// An item is being checked out.
        /// </summary>
        public override void ItemCheckingOut(SPItemEventProperties properties)
        {
            base.ItemCheckingOut(properties);
        }

        /// <summary>
        /// An item is being unchecked out.
        /// </summary>
        public override void ItemUncheckingOut(SPItemEventProperties properties)
        {
            base.ItemUncheckingOut(properties);
        }

        /// <summary>
        /// An attachment is being added to the item.
        /// </summary>
        public override void ItemAttachmentAdding(SPItemEventProperties properties)
        {
            base.ItemAttachmentAdding(properties);
        }

        /// <summary>
        /// An attachment is being removed from the item.
        /// </summary>
        public override void ItemAttachmentDeleting(SPItemEventProperties properties)
        {
            base.ItemAttachmentDeleting(properties);
        }

        /// <summary>
        /// A file is being moved.
        /// </summary>
        public override void ItemFileMoving(SPItemEventProperties properties)
        {
            base.ItemFileMoving(properties);
        }

        /// <summary>
        /// An item was added.
        /// </summary>
        public override void ItemAdded(SPItemEventProperties properties)
        {
            base.ItemAdded(properties);
        }

        /// <summary>
        /// An item was updated.
        /// </summary>
        public override void ItemUpdated(SPItemEventProperties properties)
        {
            base.ItemUpdated(properties);
        }

        /// <summary>
        /// An item was deleted.
        /// </summary>
        public override void ItemDeleted(SPItemEventProperties properties)
        {
            base.ItemDeleted(properties);
        }

        /// <summary>
        /// An item was checked in.
        /// </summary>
        public override void ItemCheckedIn(SPItemEventProperties properties)
        {
            base.ItemCheckedIn(properties);
        }

        /// <summary>
        /// An item was checked out.
        /// </summary>
        public override void ItemCheckedOut(SPItemEventProperties properties)
        {
            base.ItemCheckedOut(properties);
        }

        /// <summary>
        /// An item was unchecked out.
        /// </summary>
        public override void ItemUncheckedOut(SPItemEventProperties properties)
        {
            base.ItemUncheckedOut(properties);
        }

        /// <summary>
        /// An attachment was added to the item.
        /// </summary>
        public override void ItemAttachmentAdded(SPItemEventProperties properties)
        {
            base.ItemAttachmentAdded(properties);
        }

        /// <summary>
        /// An attachment was removed from the item.
        /// </summary>
        public override void ItemAttachmentDeleted(SPItemEventProperties properties)
        {
            base.ItemAttachmentDeleted(properties);
        }

        /// <summary>
        /// A file was moved.
        /// </summary>
        public override void ItemFileMoved(SPItemEventProperties properties)
        {
            base.ItemFileMoved(properties);
        }

        /// <summary>
        /// A file was converted.
        /// </summary>
        public override void ItemFileConverted(SPItemEventProperties properties)
        {
            base.ItemFileConverted(properties);
        }

        /// <summary>
        /// The list received a context event.
        /// </summary>
        public override void ContextEvent(SPItemEventProperties properties)
        {
            base.ContextEvent(properties);
        }
    }
}