Gezinme sağlayıcısı yazma

Bu konu, iç içe kapsayıcıları (çok düzeyli veri depoları), hareketli öğeleri ve göreli yolları destekleyen bir Windows PowerShell sağlayıcısının yöntemlerinin nasıl uygulanacağını açıklamaktadır. Gezinti sağlayıcısının System.Management.Automation.Provider.Navigationcmdletprovider sınıfından türetilmesi gerekir.

Bu konudaki örneklerdeki sağlayıcı, veri deposu olarak Access veritabanını kullanır. Veritabanıyla etkileşimde bulunmak için kullanılan çeşitli yardımcı yöntemler ve sınıflar vardır. Yardımcı yöntemleri içeren numunenin tamamı için bkz. AccessDBProviderSample05.

Windows PowerShell sağlayıcıları hakkında daha fazla bilgi için bkz. Windows PowerShell Sağlayıcısına Genel Bakış.

Gezinme yöntemlerini uygulama

System.Management.Automation.Provider.Navigationcmdletprovider sınıfı, iç içe kapsayıcıları, göreli yolları ve hareketli öğeleri destekleyen yöntemleri uygular. Bu yöntemlerin tam listesi için bkz.

Sağlayıcı sınıfını bildirme

Sağlayıcının System.Management.Automation.Provider.Navigationcmdletprovider sınıfından türeteceğini ve bunu System.Management.Automation.Provider.Cmdletprovide özelliğiyle süsleyeceğini bildirin.

[CmdletProvider("AccessDB", ProviderCapabilities.None)]
   public class AccessDBProvider : NavigationCmdletProvider
   {

   }

IsItemContainer'ı Uygulama

System.Management.Automation.Provider.Navigationcmdletprovider.Isitemcontainer* yöntemi, belirtilen yoldaki öğenin bir kapsayıcı olup olmadığını denetler.

protected override bool IsItemContainer(string path)
      {
         if (PathIsDrive(path))
         {
             return true;
         }

         string[] pathChunks = ChunkPath(path);
         string tableName;
         int rowNumber;

         PathType type = GetNamesFromPath(path, out tableName, out rowNumber);

         if (type == PathType.Table)
         {
            foreach (DatabaseTableInfo ti in GetTables())
            {
                if (string.Equals(ti.Name, tableName, StringComparison.OrdinalIgnoreCase))
                {
                    return true;
                }
            } // foreach (DatabaseTableInfo...
         } // if (pathChunks...

         return false;
      }

GetChildName'in Uygulanması

System.Management.Automation.Provider.Navigationcmdletprovider.Getchildname* yöntemi, belirtilen yoldaki alt öğenin name özelliğini alır. Belirtilen yoldaki öğe bir kapsayıcının çocuğu değilse bu yöntemin yolu döndürmesi gerekir.

protected override string GetChildName(string path)
       {
           if (PathIsDrive(path))
           {
               return path;
           }

           string tableName;
           int rowNumber;

           PathType type = GetNamesFromPath(path, out tableName, out rowNumber);

           if (type == PathType.Table)
           {
               return tableName;
           }
           else if (type == PathType.Row)
           {
               return rowNumber.ToString(CultureInfo.CurrentCulture);
           }
           else
           {
               ThrowTerminatingInvalidPathException(path);
           }

           return null;
       }

GetParentPath'in Uygulanması

System.Management.Automation.Provider.Navigationcmdletprovider.Getparentpath* yöntemi, belirtilen yoldaki öğenin üst öğesinin yolunu alır. Belirtilen yoldaki öğe veri deposunun kökü ise (yani ebeveyni yoksa), bu yöntemin kök yolu döndürmesi gerekir.

protected override string GetParentPath(string path, string root)
       {
           // If root is specified then the path has to contain
           // the root. If not nothing should be returned
           if (!String.IsNullOrEmpty(root))
           {
               if (!path.Contains(root))
               {
                   return null;
               }
           }

           return path.Substring(0, path.LastIndexOf(pathSeparator, StringComparison.OrdinalIgnoreCase));
       }

MakePath'i Uygulamak

System.Management.Automation.Provider.Navigationcmdletprovider.Makepath* yöntemi, sağlayıcı-dahili bir yol oluşturmak için belirtilen bir üst yolu ve belirtilen bir alt yolu birleştirir (sağlayıcıların destekleyebileceği yol türleri hakkında bilgi için bkz. Windows PowerShell Sağlayıcıya Genel Bakış. PowerShell Bir kullanıcı Microsoft.PowerShell.Commands.JoinPathCommand cmdlet'ini çağırdığında motor bu yöntemi çağırır.

protected override string MakePath(string parent, string child)
       {
           string result;

           string normalParent = NormalizePath(parent);
           normalParent = RemoveDriveFromPath(normalParent);
           string normalChild = NormalizePath(child);
           normalChild = RemoveDriveFromPath(normalChild);

           if (String.IsNullOrEmpty(normalParent) && String.IsNullOrEmpty(normalChild))
           {
               result = String.Empty;
           }
           else if (String.IsNullOrEmpty(normalParent) && !String.IsNullOrEmpty(normalChild))
           {
               result = normalChild;
           }
           else if (!String.IsNullOrEmpty(normalParent) && String.IsNullOrEmpty(normalChild))
           {
               if (normalParent.EndsWith(pathSeparator, StringComparison.OrdinalIgnoreCase))
               {
                   result = normalParent;
               }
               else
               {
                   result = normalParent + pathSeparator;
               }
           } // else if (!String...
           else
           {
               if (!normalParent.Equals(String.Empty) &&
                   !normalParent.EndsWith(pathSeparator, StringComparison.OrdinalIgnoreCase))
               {
                   result = normalParent + pathSeparator;
               }
               else
               {
                   result = normalParent;
               }

               if (normalChild.StartsWith(pathSeparator, StringComparison.OrdinalIgnoreCase))
               {
                   result += normalChild.Substring(1);
               }
               else
               {
                   result += normalChild;
               }
           } // else

           return result;
       }

NormalizeRelativePath'in Uygulanması

System.Management.Automation.Provider.Navigationcmdletprovider.Normalizerelativepath* yöntemi, path ve basepath parametrelerini alır ve path'e eşdeğer normalleştirilmiş bir yol döndürür parametresine ve basepath parametresine göredir.

protected override string NormalizeRelativePath(string path,
                                                            string basepath)
       {
           // Normalize the paths first
           string normalPath = NormalizePath(path);
           normalPath = RemoveDriveFromPath(normalPath);
           string normalBasePath = NormalizePath(basepath);
           normalBasePath = RemoveDriveFromPath(normalBasePath);

           if (String.IsNullOrEmpty(normalBasePath))
           {
               return normalPath;
           }
           else
           {
               if (!normalPath.Contains(normalBasePath))
               {
                   return null;
               }

               return normalPath.Substring(normalBasePath.Length + pathSeparator.Length);
           }
       }

MoveItem'in Uygulanması

System.Management.Automation.Provider.Navigationcmdletprovider.Moveitem* yöntemi, bir öğeyi belirtilen yoldan belirtilen hedef yola taşır. Bir kullanıcı Microsoft.PowerShell.Commands.MoveItemCommand cmdlet'ini çağırdığında PowerShell motoru bu yöntemi çağırır.

protected override void MoveItem(string path, string destination)
       {
           // Get type, table name and rowNumber from the path
           string tableName, destTableName;
           int rowNumber, destRowNumber;

           PathType type = GetNamesFromPath(path, out tableName, out rowNumber);

           PathType destType = GetNamesFromPath(destination, out destTableName,
                                    out destRowNumber);

           if (type == PathType.Invalid)
           {
               ThrowTerminatingInvalidPathException(path);
           }

           if (destType == PathType.Invalid)
           {
               ThrowTerminatingInvalidPathException(destination);
           }

           if (type == PathType.Table)
           {
               ArgumentException e = new ArgumentException("Move not supported for tables");

               WriteError(new ErrorRecord(e, "MoveNotSupported",
                   ErrorCategory.InvalidArgument, path));

               throw e;
           }
           else
           {
               OdbcDataAdapter da = GetAdapterForTable(tableName);
               if (da == null)
               {
                   return;
               }

               DataSet ds = GetDataSetForTable(da, tableName);
               DataTable table = GetDataTable(ds, tableName);

               OdbcDataAdapter dda = GetAdapterForTable(destTableName);
               if (dda == null)
               {
                   return;
               }

               DataSet dds = GetDataSetForTable(dda, destTableName);
               DataTable destTable = GetDataTable(dds, destTableName);
               DataRow row = table.Rows[rowNumber];

               if (destType == PathType.Table)
               {
                   DataRow destRow = destTable.NewRow();

                   destRow.ItemArray = row.ItemArray;
               }
               else
               {
                   DataRow destRow = destTable.Rows[destRowNumber];

                   destRow.ItemArray = row.ItemArray;
               }

               // Update the changes
               if (ShouldProcess(path, "MoveItem"))
               {
                   WriteItemObject(row, path, false);
                   dda.Update(dds, destTableName);
               }
           }
       }

Ayrıca Bakınız

Bir konteyner sağlayıcısı yazma

Windows PowerShell Sağlayıcısına Genel Bakış