/// <summary>
/// Process local paths
/// </summary>
/// <param name="path"></param>
/// <param name="discoveryClientProtocol"></param>
private void ProcessLocal(string path, DiscoveryClientProtocol discoveryClientProtocol)
{
string extension = Path.GetExtension(path);
if (string.Compare(extension, ".discomap", true) == 0)
{
discoveryClientProtocol.ReadAll(path);
}
else
{
object obj = null;
if (string.Compare(extension, ".wsdl", true) == 0)
{
obj = this.ReadLocalDocument(false, path);
}
else
{
if (string.Compare(extension, ".xsd", true) != 0)
{
throw new InvalidOperationException("Unknown file type " + path);
}
obj = this.ReadLocalDocument(true, path);
}
if (obj != null)
{
this.AddDocument(path, obj);
}
}
}
private void ProcessLocalPaths(DiscoveryClientProtocol client, StringCollection localPaths, XmlSchemas schemas,
ServiceDescriptionCollection descriptions)
{
StringEnumerator enumerator = localPaths.GetEnumerator();
while (enumerator.MoveNext())
{
string current = enumerator.Current;
string extension = Path.GetExtension(current);
if (string.Compare(extension, ".discomap", true) == 0)
{
client.ReadAll(current);
}
else
{
object document = null;
if (string.Compare(extension, ".wsdl", true) == 0)
{
document = ReadLocalDocument(false, current);
}
else
{
if (string.Compare(extension, ".xsd", true) != 0)
{
throw new InvalidOperationException("Unknown file type " + current);
}
document = ReadLocalDocument(true, current);
}
if (document != null)
{
AddDocument(current, document, schemas, descriptions);
}
}
}
}
private void ProcessLocalPaths(DiscoveryClientProtocol client, StringCollection localPaths, XmlSchemas schemas,
ServiceDescriptionCollection descriptions)
{
foreach (string text1 in localPaths)
{
string text2 = Path.GetExtension(text1);
if (string.Compare(text2, ".discomap", true) == 0)
{
client.ReadAll(text1);
}
else
{
object obj1 = null;
if (string.Compare(text2, ".wsdl", true) == 0)
{
obj1 = ReadLocalDocument(false, text1);
}
else
{
if (string.Compare(text2, ".xsd", true) != 0)
{
throw new InvalidOperationException("Unknown file type " + text1);
}
obj1 = ReadLocalDocument(true, text1);
}
if (obj1 != null)
{
AddDocument(text1, obj1, schemas, descriptions);
}
}
}
}
static void Main()
{
try
{
DiscoveryClientProtocol myDiscoveryClientProtocol =
new DiscoveryClientProtocol();
// Get the collection holding DiscoveryClientResult objects.
DiscoveryClientResultCollection myDiscoveryClientResultCollection =
myDiscoveryClientProtocol.ReadAll("results.discomap");
Console.WriteLine("The number of DiscoveryClientResult objects: "
+ myDiscoveryClientResultCollection.Count);
Console.WriteLine("Displaying the items in the collection:");
// Iterate through the collection and display the properties
// of each DiscoveryClientResult in it.
foreach (DiscoveryClientResult myDiscoveryClientResult in
myDiscoveryClientResultCollection)
{
Console.WriteLine(
"Type of reference in the discovery document: "
+ myDiscoveryClientResult.ReferenceTypeName);
Console.WriteLine("Url for the reference: "
+ myDiscoveryClientResult.Url);
Console.WriteLine("File for saving the reference: "
+ myDiscoveryClientResult.Filename);
}
}
catch (Exception e)
{
Console.WriteLine("Error is " + e.Message);
}
}
public static DynamicProxyLoader Load(String fileName, String @namespace, DynamicProxyLoaderOptions options)
{
@namespace = (@namespace ?? "Hmis_Service_Ref");
options = (options ?? new DynamicProxyLoaderOptions());
var dynamicProxyFactory = ReadCache(fileName);
if (dynamicProxyFactory != null)
{
return(dynamicProxyFactory);
}
var proxyClientFileName = String.Format("{0}.config", fileName);
var proxyAssemblyFileName = String.Format("{0}.dll", fileName);
var proxyCodeFileName = String.Format("{0}.cs", fileName);
var discoveryClient = new DiscoveryClientProtocol();
discoveryClient.ReadAll(proxyClientFileName);
var proxyAssemblyBytes = File.ReadAllBytes(proxyAssemblyFileName);
var proxyAssemblyCode = File.ReadAllText(proxyCodeFileName);
var proxyAssembly = Assembly.Load(proxyAssemblyBytes);
dynamicProxyFactory = new DynamicProxyLoader(discoveryClient, proxyAssembly, proxyAssemblyBytes, proxyAssemblyCode, @namespace, options);
WriteCache(fileName, dynamicProxyFactory);
return(dynamicProxyFactory);
}
ReferenceGroup ConvertMapFile(string mapFile)
{
DiscoveryClientResultCollection files;
using (var prot = new DiscoveryClientProtocol())
files = prot.ReadAll(mapFile);
var map = new ReferenceGroup();
if (refGroup != null)
{
map.ClientOptions = refGroup.ClientOptions;
map.ID = refGroup.ID;
}
else
{
map.ClientOptions = defaultOptions;
map.ID = Guid.NewGuid().ToString();
}
var sources = new Dictionary <string, int> ();
foreach (DiscoveryClientResult res in files)
{
string url = res.Url;
var uri = new Uri(url);
if (!string.IsNullOrEmpty(uri.Query))
{
url = url.Substring(0, url.Length - uri.Query.Length);
}
int nSource;
if (!sources.TryGetValue(url, out nSource))
{
nSource = sources.Count + 1;
sources [url] = nSource;
var ms = new MetadataSource();
ms.Address = url;
ms.Protocol = uri.Scheme;
ms.SourceId = nSource.ToString();
map.MetadataSources.Add(ms);
}
var file = new MetadataFile();
file.FileName = res.Filename;
file.ID = Guid.NewGuid().ToString();
file.SourceId = nSource.ToString();
file.SourceUrl = res.Url;
switch (Path.GetExtension(file.FileName).ToLower())
{
case ".disco": file.MetadataType = "Disco"; break;
case ".wsdl": file.MetadataType = "Wsdl"; break;
case ".xsd": file.MetadataType = "Schema"; break;
}
map.Metadata.Add(file);
}
map.Save(mapFile);
return(map);
}
/// <summary>
/// protocol.ReadAll fails on Mono 4.2 but not on Mono 4.0 since the
/// generated Reference.map file contains an incorrect filename.
/// </summary>
static void ReadReferenceMap(string directory)
{
var protocol = new DiscoveryClientProtocol();
var results = protocol.ReadAll(Path.Combine(directory, "Reference.map"));
foreach (DiscoveryClientResult result in results)
{
Console.WriteLine(result.Filename);
}
}
static void Main()
{
try
{
DiscoveryClientProtocol myDiscoveryClientProtocol =
new DiscoveryClientProtocol();
// Get the collection of DiscoveryClientResult objects.
DiscoveryClientResultCollection myDiscoveryClientResultCollection =
myDiscoveryClientProtocol.ReadAll("results.discomap");
Console.WriteLine("The number of DiscoveryClientResult objects: "
+ myDiscoveryClientResultCollection.Count);
Console.WriteLine("Removing a DiscoveryClientResult "
+ "from the collection...");
// Remove first DiscoveryClientResult from the collection.
myDiscoveryClientResultCollection.Remove
(myDiscoveryClientResultCollection[0]);
Console.WriteLine("Adding a DiscoveryClientResult "
+ "to the collection...");
// <Snippet1>
// Initialize a new instance of the DiscoveryClientResult class.
DiscoveryClientResult myDiscoveryClientResult =
new DiscoveryClientResult(
typeof(System.Web.Services.Discovery.DiscoveryDocumentReference),
"http://localhost/Discovery/Service1_cs.asmx?disco",
"Service1_cs.disco");
// Add the DiscoveryClientResult to the collection.
myDiscoveryClientResultCollection.Add(myDiscoveryClientResult);
// </Snippet1>
Console.WriteLine("Displaying the items in the collection");
for (int i = 0; i < myDiscoveryClientResultCollection.Count; i++)
{
DiscoveryClientResult myClientResult =
myDiscoveryClientResultCollection[i];
Console.WriteLine("DiscoveryClientResult Object " + (i + 1));
Console.WriteLine("Type of reference in the discovery document: "
+ myClientResult.ReferenceTypeName);
Console.WriteLine("URL for reference: " + myClientResult.Url);
Console.WriteLine("File for saving the reference: "
+ myClientResult.Filename);
}
}
catch (Exception e)
{
Console.WriteLine("Error is " + e.Message);
}
}
private MetadataSet DiscoverMetadataFromMapFile(string file)
{
string mapFile = Path.ChangeExtension(file, MapFileExtension);
using (DiscoveryClientProtocol discovery = new DiscoveryClientProtocol())
{
discovery.ReadAll(mapFile);
MetadataSet metadataSet = new MetadataSet();
foreach (object document in discovery.Documents.Values)
{
metadataSet.MetadataSections.Add(CreateMetadataSection(document));
}
return(metadataSet);
}
}
static void Main()
{
try
{
DiscoveryClientProtocol myDiscoveryClientProtocol =
new DiscoveryClientProtocol();
// Get the collection of DiscoveryClientResult objects.
DiscoveryClientResultCollection myDiscoveryClientResultCollection =
myDiscoveryClientProtocol.ReadAll("results.discomap");
Console.WriteLine(
"Removing a DiscoveryClientResult from the collection...");
// Remove the first DiscoveryClientResult from the collection.
myDiscoveryClientResultCollection.Remove(
myDiscoveryClientResultCollection[0]);
Console.WriteLine("Adding a DiscoveryClientResult" +
" to the collection...");
DiscoveryClientResult myDiscoveryClientResult =
new DiscoveryClientResult();
// Set the DiscoveryDocumentReference class as the type of
// reference in the discovery document.
myDiscoveryClientResult.ReferenceTypeName =
"System.Web.Services.Discovery.DiscoveryDocumentReference";
// Set the URL for the reference.
myDiscoveryClientResult.Url =
"http://localhost/Discovery/Service1_cs.asmx?disco";
// Set the name of the file in which the reference is saved.
myDiscoveryClientResult.Filename = "Service1_cs.disco";
// Add myDiscoveryClientResult to the collection.
myDiscoveryClientResultCollection.Add(myDiscoveryClientResult);
if (myDiscoveryClientResultCollection.Contains(myDiscoveryClientResult))
{
Console.WriteLine(
"Instance of DiscoveryClientResult found in the Collection");
}
}
catch (Exception ex)
{
Console.WriteLine("Error is " + ex.Message);
}
}
public void ReadWriteTest()
{
string directory = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
Directory.CreateDirectory(directory);
try {
string url = "http://www.w3schools.com/WebServices/TempConvert.asmx";
var p1 = new DiscoveryClientProtocol();
p1.DiscoverAny(url);
p1.ResolveAll();
p1.WriteAll(directory, "Reference.map");
var p2 = new DiscoveryClientProtocol();
var results = p2.ReadAll(Path.Combine(directory, "Reference.map"));
Assert.AreEqual(2, results.Count);
Assert.AreEqual("TempConvert.disco", results [0].Filename);
Assert.AreEqual("TempConvert.wsdl", results [1].Filename);
} finally {
Directory.Delete(directory, true);
}
}
static void Main()
{
try
{
DiscoveryClientProtocol myDiscoveryClientProtocol =
new DiscoveryClientProtocol();
// Get the collection of DiscoveryClientResult objects.
DiscoveryClientResultCollection myDiscoveryClientResultCollection =
myDiscoveryClientProtocol.ReadAll("results.discomap");
Console.WriteLine("The number of DiscoveryClientResult objects: "
+ myDiscoveryClientResultCollection.Count);
Console.WriteLine(
"Removing a DiscoveryClientResult from the collection...");
// <Snippet1>
// Remove the first DiscoveryClientResult from the collection.
myDiscoveryClientResultCollection.Remove(
myDiscoveryClientResultCollection[0]);
// </Snippet1>
Console.WriteLine(
"Adding a DiscoveryClientResult to the collection...");
// <Snippet2>
// <Snippet3>
// <Snippet4>
// <Snippet5>
// <Snippet6>
// Initialize new instance of the DiscoveryClientResult class.
DiscoveryClientResult myDiscoveryClientResult =
new DiscoveryClientResult();
// Set the type of reference in the discovery document as
// DiscoveryDocumentReference.
myDiscoveryClientResult.ReferenceTypeName =
"System.Web.Services.Discovery.DiscoveryDocumentReference";
// Set the URL for the reference.
myDiscoveryClientResult.Url =
"http://localhost/Discovery/Service1_cs.asmx?disco";
// Set the name of the file in which the reference is saved.
myDiscoveryClientResult.Filename = "Service1_cs.disco";
// Add the DiscoveryClientResult to the collection.
myDiscoveryClientResultCollection.Add(myDiscoveryClientResult);
// </Snippet6>
// </Snippet5>
// </Snippet4>
// </Snippet3>
// </Snippet2>
// <Snippet7>
if (myDiscoveryClientResultCollection.Contains(
myDiscoveryClientResult))
{
Console.WriteLine(
"The collection contains the specified " +
"DiscoveryClientResult instance.");
}
// </Snippet7>
Console.WriteLine("Displaying the items in collection");
// <Snippet8>
for (int i = 0; i < myDiscoveryClientResultCollection.Count; i++)
{
DiscoveryClientResult myClientResult =
myDiscoveryClientResultCollection[i];
Console.WriteLine("DiscoveryClientResult " + (i + 1));
Console.WriteLine("Type of reference in the discovery document: "
+ myClientResult.ReferenceTypeName);
Console.WriteLine("Url for reference:" + myClientResult.Url);
Console.WriteLine("File for saving the reference: "
+ myClientResult.Filename);
}
// </Snippet8>
}
catch (Exception e)
{
Console.WriteLine("Error is " + e.Message);
}
}
public override void GenerateCode(AssemblyBuilder assemblyBuilder)
{
// Only attempt to get the Indigo provider once
if (!s_triedToGetWebRefType)
{
s_indigoWebRefProviderType = BuildManager.GetType(IndigoWebRefProviderTypeName, false /*throwOnError*/);
s_triedToGetWebRefType = true;
}
// If we have an Indigo provider, instantiate it and forward the GenerateCode call to it
if (s_indigoWebRefProviderType != null)
{
BuildProvider buildProvider = (BuildProvider)HttpRuntime.CreateNonPublicInstance(s_indigoWebRefProviderType);
buildProvider.SetVirtualPath(VirtualPathObject);
buildProvider.GenerateCode(assemblyBuilder);
}
// e.g "/MyApp/Application_WebReferences"
VirtualPath rootWebRefDirVirtualPath = HttpRuntime.WebRefDirectoryVirtualPath;
// e.g "/MyApp/Application_WebReferences/Foo/Bar"
string currentWebRefDirVirtualPath = _vdir.VirtualPath;
Debug.Assert(StringUtil.StringStartsWithIgnoreCase(
currentWebRefDirVirtualPath, rootWebRefDirVirtualPath.VirtualPathString));
string ns;
if (rootWebRefDirVirtualPath.VirtualPathString.Length == currentWebRefDirVirtualPath.Length)
{
// If it's the root WebReferences dir, use the empty namespace
ns = String.Empty;
}
else
{
// e.g. "Foo/Bar"
Debug.Assert(rootWebRefDirVirtualPath.HasTrailingSlash);
currentWebRefDirVirtualPath = UrlPath.RemoveSlashFromPathIfNeeded(currentWebRefDirVirtualPath);
currentWebRefDirVirtualPath = currentWebRefDirVirtualPath.Substring(
rootWebRefDirVirtualPath.VirtualPathString.Length);
// Split it into chunks separated by '/'
string[] chunks = currentWebRefDirVirtualPath.Split('/');
// Turn all the relevant chunks into valid namespace chunks
for (int i = 0; i < chunks.Length; i++)
{
chunks[i] = Util.MakeValidTypeNameFromString(chunks[i]);
}
// Put the relevant chunks back together to form the namespace
ns = String.Join(".", chunks);
}
#if !FEATURE_PAL // FEATURE_PAL does not support System.Web.Services
CodeNamespace codeNamespace = new CodeNamespace(ns);
// for each discomap file, read all references and add them to the WebReferenceCollection
WebReferenceCollection webs = new WebReferenceCollection();
bool hasDiscomap = false;
// Go through all the discomap in the directory
foreach (VirtualFile child in _vdir.Files)
{
string extension = UrlPath.GetExtension(child.VirtualPath);
extension = extension.ToLower(CultureInfo.InvariantCulture);
if (extension == ".discomap")
{
// NOTE: the WebReferences code requires physical path, so this feature
// cannot work with a non-file based VirtualPathProvider
string physicalPath = HostingEnvironment.MapPath(child.VirtualPath);
DiscoveryClientProtocol client = new DiscoveryClientProtocol();
client.AllowAutoRedirect = true;
client.Credentials = CredentialCache.DefaultCredentials;
client.ReadAll(physicalPath);
WebReference webRefTemp = new WebReference(client.Documents, codeNamespace);
//
string fileName = System.IO.Path.ChangeExtension(UrlPath.GetFileName(child.VirtualPath), null);
string appSetttingUrlKey = ns + "." + fileName;
WebReference web = new WebReference(client.Documents, codeNamespace, webRefTemp.ProtocolName, appSetttingUrlKey, null);
webs.Add(web);
hasDiscomap = true;
}
}
// If we didn't find any discomap files, we have nothing to generate
if (!hasDiscomap)
{
return;
}
CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
codeCompileUnit.Namespaces.Add(codeNamespace);
//public static StringCollection GenerateWebReferences(WebReferenceCollection webReferences, CodeDomProvider codeProvider, CodeCompileUnit codeCompileUnit, WebReferenceOptions options) {
WebReferenceOptions options = new WebReferenceOptions();
options.CodeGenerationOptions = CodeGenerationOptions.GenerateProperties | CodeGenerationOptions.GenerateNewAsync | CodeGenerationOptions.GenerateOldAsync;
options.Style = ServiceDescriptionImportStyle.Client;
options.Verbose = true;
StringCollection shareWarnings = ServiceDescriptionImporter.GenerateWebReferences(webs, assemblyBuilder.CodeDomProvider, codeCompileUnit, options);
// Add the CodeCompileUnit to the compilation
assemblyBuilder.AddCodeCompileUnit(this, codeCompileUnit);
#else // !FEATURE_PAL
return;
#endif // !FEATURE_PAL
}
public override void GenerateCode(AssemblyBuilder assemblyBuilder)
{
string str2;
if (!s_triedToGetWebRefType)
{
s_indigoWebRefProviderType = BuildManager.GetType("System.Web.Compilation.WCFBuildProvider", false);
s_triedToGetWebRefType = true;
}
if (s_indigoWebRefProviderType != null)
{
BuildProvider provider = (BuildProvider)HttpRuntime.CreateNonPublicInstance(s_indigoWebRefProviderType);
provider.SetVirtualPath(base.VirtualPathObject);
provider.GenerateCode(assemblyBuilder);
}
VirtualPath webRefDirectoryVirtualPath = HttpRuntime.WebRefDirectoryVirtualPath;
string virtualPath = this._vdir.VirtualPath;
if (webRefDirectoryVirtualPath.VirtualPathString.Length == virtualPath.Length)
{
str2 = string.Empty;
}
else
{
string[] strArray = UrlPath.RemoveSlashFromPathIfNeeded(virtualPath).Substring(webRefDirectoryVirtualPath.VirtualPathString.Length).Split(new char[] { '/' });
for (int i = 0; i < strArray.Length; i++)
{
strArray[i] = Util.MakeValidTypeNameFromString(strArray[i]);
}
str2 = string.Join(".", strArray);
}
CodeNamespace proxyCode = new CodeNamespace(str2);
WebReferenceCollection webReferences = new WebReferenceCollection();
bool flag = false;
foreach (VirtualFile file in this._vdir.Files)
{
if (UrlPath.GetExtension(file.VirtualPath).ToLower(CultureInfo.InvariantCulture) == ".discomap")
{
string topLevelFilename = HostingEnvironment.MapPath(file.VirtualPath);
DiscoveryClientProtocol protocol = new DiscoveryClientProtocol {
AllowAutoRedirect = true,
Credentials = CredentialCache.DefaultCredentials
};
protocol.ReadAll(topLevelFilename);
WebReference reference = new WebReference(protocol.Documents, proxyCode);
string str5 = Path.ChangeExtension(UrlPath.GetFileName(file.VirtualPath), null);
string appSettingUrlKey = str2 + "." + str5;
WebReference webReference = new WebReference(protocol.Documents, proxyCode, reference.ProtocolName, appSettingUrlKey, null);
webReferences.Add(webReference);
flag = true;
}
}
if (flag)
{
CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
codeCompileUnit.Namespaces.Add(proxyCode);
WebReferenceOptions options = new WebReferenceOptions {
CodeGenerationOptions = CodeGenerationOptions.GenerateOldAsync | CodeGenerationOptions.GenerateNewAsync | CodeGenerationOptions.GenerateProperties,
Style = ServiceDescriptionImportStyle.Client,
Verbose = true
};
ServiceDescriptionImporter.GenerateWebReferences(webReferences, assemblyBuilder.CodeDomProvider, codeCompileUnit, options);
assemblyBuilder.AddCodeCompileUnit(this, codeCompileUnit);
}
}
