Core/Castle.Core/Resource/AssemblyResource.cs

   1 // Copyright 2004-2008 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Castle.Core.Resource
  16 {
  17         using System;
  18         using System.IO;
  19         using System.Reflection;
  20
  21         public class AssemblyResource : AbstractStreamResource
  22         {
  23                 private string assemblyName;
  24                 private string resourcePath;
  25                 private String basePath;
  26
  27                 public AssemblyResource(CustomUri resource)
  28                 {
  29                         CreateStream = delegate
  30                         {
  31                                 return CreateResourceFromUri(resource, null);
  32                         };
  33                 }
  34
  35                 public AssemblyResource(CustomUri resource, String basePath)
  36                 {
  37                         CreateStream = delegate
  38                         {
  39                                 return CreateResourceFromUri(resource, basePath);
  40                         };
  41                 }
  42
  43                 public AssemblyResource(String resource)
  44                 {
  45                         CreateStream = delegate
  46                         {
  47                                 return CreateResourceFromPath(resource, basePath);
  48                         };
  49                 }
  50
  51                 public override IResource CreateRelative(String resourceName)
  52                 {
  53                         throw new NotImplementedException();
  54                 }
  55
  56                 public override string ToString()
  57                 {
  58                         return String.Format("AssemblyResource: [{0}] [{1}]", assemblyName, resourcePath);
  59                 }
  60
  61                 private Stream CreateResourceFromPath(String resource, String path)
  62                 {
  63                         if (!resource.StartsWith("assembly" + CustomUri.SchemeDelimiter))
  64                         {
  65                                 resource = "assembly" + CustomUri.SchemeDelimiter + resource;
  66                         }
  67
  68                         return CreateResourceFromUri(new CustomUri(resource), path);
  69                 }
  70
  71                 private Stream CreateResourceFromUri(CustomUri resourcex, String basePath)
  72                 {
  73                         if (resourcex == null) throw new ArgumentNullException("resourcex");
  74
  75                         assemblyName = resourcex.Host;
  76                         resourcePath = ConvertToResourceName(assemblyName, resourcex.Path, basePath);
  77
  78                         Assembly assembly = ObtainAssembly(assemblyName);
  79
  80                         String[] names = assembly.GetManifestResourceNames();
  81
  82                         String nameFound = GetNameFound(names);
  83
  84                         if (nameFound == null)
  85                         {
  86                                 resourcePath = resourcex.Path.Replace('/', '.').Substring(1);
  87                                 nameFound = GetNameFound(names);
  88                         }
  89
  90                         if (nameFound == null)
  91                         {
  92                                 String message = String.Format("The assembly resource {0} could not be located", resourcePath);
  93                                 throw new ResourceException(message);
  94                         }
  95
  96                         this.basePath = ConvertToPath(resourcePath);
  97
  98                         return assembly.GetManifestResourceStream(nameFound);
  99                 }
 100
 101                 private string GetNameFound(string[] names)
 102                 {
 103                         string nameFound = null;
 104                         foreach(String name in names)
 105                         {
 106                                 if (String.Compare(resourcePath, name, true) == 0)
 107                                 {
 108                                         nameFound = name;
 109                                         break;
 110                                 }
 111                         }
 112                         return nameFound;
 113                 }
 114
 115                 private string ConvertToResourceName(String assemblyName, String resource, String basePath)
 116                 {
 117                         // TODO: use basePath for relative name construction
 118                         return String.Format("{0}{1}", assemblyName, resource.Replace('/', '.'));
 119                 }
 120
 121                 private string ConvertToPath(String resource)
 122                 {
 123                         string path = resource.Replace('.', '/');
 124                         if (path[0] != '/')
 125                         {
 126                                 path = string.Format("/{0}", path);
 127                         }
 128                         return path;
 129                 }
 130
 131                 private static Assembly ObtainAssembly(String assemblyName)
 132                 {
 133                         try
 134                         {
 135                                 return Assembly.Load(assemblyName);
 136                         }
 137                         catch(Exception ex)
 138                         {
 139                                 String message = String.Format("The assembly {0} could not be loaded", assemblyName);
 140                                 throw new ResourceException(message, ex);
 141                         }
 142                 }
 143         }
 144 }