Kontinuierlicher Dateizugriff im Webservice mit Sperren nicht verhindern

Question

Ich habe einen Webservice (.asmx) erstellt, der mit ajax beim Seitenladeereignis jeder Seite aufgerufen wird. Es wird im Wesentlichen verwendet, um das Verhalten von Webseitenbenutzern aufzuzeichnen. Ich serialisiert diese erfasste Information in eine XML-Datei. Dies ist die Methode, die ich verwende.

public static void SerializeObject<T>(T serializableObject, string fileName) 
    { 

      if (serializableObject == null) { return; } 

      try 
      { 
       XmlDocument xmlDocument = new XmlDocument(); 
       XmlSerializer serializer = new XmlSerializer(serializableObject.GetType()); 
       using (MemoryStream stream = new MemoryStream()) 
       { 
        serializer.Serialize(stream, serializableObject); 
        stream.Position = 0; 
        xmlDocument.Load(stream); 
        xmlDocument.Save(fileName); 
        stream.Close(); 
       } 
      } 
      catch (Exception ex) 
      { 
       //Log exception here 
      } 

    } 
    public static T DeSerializeObject<T>(string fileName) 
    { 

      if (string.IsNullOrEmpty(fileName)) { return default(T); } 

      T objectOut = default(T); 

      try 
      { 
       XmlDocument xmlDocument = new XmlDocument(); 
       xmlDocument.Load(fileName); 
       string xmlString = xmlDocument.OuterXml; 

       using (StringReader read = new StringReader(xmlString)) 
       { 
        Type outType = typeof(T); 

        XmlSerializer serializer = new XmlSerializer(outType); 
        using (XmlReader reader = new XmlTextReader(read)) 
        { 
         objectOut = (T)serializer.Deserialize(reader); 
         reader.Close(); 
        } 

        read.Close(); 
       } 
      } 
      catch (Exception ex) 
      { 
       //Log exception here 
      } 

      return objectOut; 

    } 

    public static List<UserPath> saveandfetch<T>(string sord, string filename, T serializableObject=default(T)) 
    { 
     lock (locker) 
     { 
      if (sord == "S") 
      { 
       List<UserPath> up = serializableObject as List<UserPath>; 
       SerializeObject<List<UserPath>>(up, filename); 
       return null; 
      } 
      else if (sord == "D") 
      { 
       List<UserPath> up = DeSerializeObject<List<UserPath>>(filename); 
       return up; 
      } 
      else 
      { 
       return null; 
      } 
     } 
    } 

Th dritte Funktion verwendet, um sowohl serialize und de-serialize durch die richtigen functions.I haben Aufruf eine Sperre auf diese Funktion gesetzt. Das Problem tritt jedoch auch danach auf, wenn zwei oder mehr Benutzer gleichzeitig die Daten überschreiben.

Ich rufe die Funktion wie folgt aus:

List<UserPath> UPL = saveandfetch<List<UserPath>>("D",Server.MapPath("/UserPath.xml"));//deserialize 

    saveandfetch<List<UserPath>>("S",Server.MapPath("/UserPath.xml"),UPL); //serialize 

Was mache ich falsch?

static object locker = new object(); 

wird auf diese Weise nur einmal und für alle Funktionsaufrufe verwendet erstellt werden:

Answer 1

Um sollte richtig Spind Objekt verriegeln, wie deklariert werden.