public void LoadXml(XmlElement value)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
XmlNamespaceManager nsm = new XmlNamespaceManager(value.OwnerDocument.NameTable);
nsm.AddNamespace("enc", XmlNameSpace.Url[NS.XmlEncNamespaceUrl]);
XmlElement encryptionMethodElement = value;
var algorithmUrl = ElementUtils.GetAttribute(encryptionMethodElement, "Algorithm", NS.XmlEncNamespaceUrl);
_algorithm = XmlNameSpace.Url.FirstOrDefault(x => x.Value == algorithmUrl).Key;
XmlNode keySizeNode = value.SelectSingleNode("enc:KeySize", nsm);
if (keySizeNode != null)
{
KeySize = Convert.ToInt32(ParserUtils.DiscardWhiteSpaces(keySizeNode.InnerText), null);
}
_cachedXml = value;
}
public static void GetC14NDigest(IHash hash, SignedXml signedXml)
{
bool isKeyedHashAlgorithm = hash is MacHashWrapper;
if (isKeyedHashAlgorithm || !signedXml.IsCacheValid || !signedXml.SignedInfo.CacheValid)
{
string baseUri = (signedXml.ContainingDocument == null ? null : signedXml.ContainingDocument.BaseURI);
XmlResolver resolver = (signedXml._bResolverSet ? signedXml._xmlResolver : new XmlSecureResolver(new XmlUrlResolver(), baseUri));
XmlDocument doc = StreamUtils.PreProcessElementInput(signedXml.SignedInfo.GetXml(), resolver, baseUri);
CanonicalXmlNodeList namespaces = (signedXml._context == null ? null : ElementUtils.GetPropagatedAttributes(signedXml._context));
SignedXmlDebugLog.LogNamespacePropagation(signedXml, namespaces);
ElementUtils.AddNamespaces(doc.DocumentElement, namespaces);
Transform c14nMethodTransform = signedXml.SignedInfo.CanonicalizationMethodObject;
c14nMethodTransform.Resolver = resolver;
c14nMethodTransform.BaseURI = baseUri;
SignedXmlDebugLog.LogBeginCanonicalization(signedXml, c14nMethodTransform);
c14nMethodTransform.LoadInput(doc);
SignedXmlDebugLog.LogCanonicalizedOutput(signedXml, c14nMethodTransform);
c14nMethodTransform.GetDigestedOutput(hash);
signedXml.IsCacheValid = !isKeyedHashAlgorithm;
}
}
private void ColorVisibleElement()
{
var view = _doc.ActiveView;
var elemIds = ElementUtils.GetElementInstanceInView(_doc, view).Select(x => x.Id).ToList();
RunSetColor(view, elemIds);
}
internal void LoadXml(XmlElement value)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
XmlNamespaceManager nsm = new XmlNamespaceManager(value.OwnerDocument.NameTable);
nsm.AddNamespace("ds", XmlNameSpace.Url[NS.XmlDsigNamespaceUrl]);
XmlNodeList transformNodes = value.SelectNodes("ds:Transform", nsm);
if (transformNodes.Count == 0)
{
throw new System.Security.Cryptography.CryptographicException(SR.Cryptography_Xml_InvalidElement, "Transforms");
}
_transforms.Clear();
for (int i = 0; i < transformNodes.Count; ++i)
{
XmlElement transformElement = (XmlElement)transformNodes.Item(i);
string algorithm = ElementUtils.GetAttribute(transformElement, "Algorithm", NS.XmlDsigNamespaceUrl);
Transform transform = CryptoHelpers.CreateFromName <Transform>(algorithm);
if (transform == null)
{
throw new System.Security.Cryptography.CryptographicException(SR.Cryptography_Xml_UnknownTransform);
}
transform.LoadInnerXml(transformElement.ChildNodes);
_transforms.Add(transform);
}
}
private void ColorSelectedElement()
{
var view = _doc.ActiveView;
var elemIds = ElementUtils.GetElementPreSelected(_doc).Select(x => x.Id).ToList();
RunSetColor(view, elemIds);
}
private static Skill RandomSkillOut(IEnumerable <Element> elements)
{
List <Element> includedElements = ElementUtils.GetAllElements();
includedElements.RemoveAll(e => elements.Contains(e));
return(RandomSkillIn(includedElements));
}
public override void LoadInnerXml(XmlNodeList nodeList)
{
if (nodeList != null)
{
foreach (XmlNode n in nodeList)
{
XmlElement e = n as XmlElement;
if (e != null)
{
if (e.LocalName.Equals("InclusiveNamespaces") &&
e.NamespaceURI.Equals(NS.XmlDsigExcC14NTransformUrl) &&
ElementUtils.HasAttribute(e, "PrefixList", XmlNameSpace.Url[NS.XmlDsigNamespaceUrl]))
{
if (!ElementUtils.VerifyAttributes(e, "PrefixList"))
{
throw new System.Security.Cryptography.CryptographicException(SR.Cryptography_Xml_UnknownTransform);
}
this.InclusiveNamespacesPrefixList = ElementUtils.GetAttribute(e, "PrefixList", NS.XmlDsigNamespaceUrl);
return;
}
else
{
throw new System.Security.Cryptography.CryptographicException(SR.Cryptography_Xml_UnknownTransform);
}
}
}
}
}
public void Configure(SpriteTemplate sprite, Element element = Element.NONE)
{
int i = (int)sprite;
((AtlasTexture)Texture).Region = new Rect2((i % 4) * SIZE, (i / 4) * SIZE, DIM);
Modulate = ElementUtils.GetColor(element);
}
public virtual void LoadXml(XmlElement value)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
ReferenceType = value.LocalName;
string uri = ElementUtils.GetAttribute(value, "URI", NS.XmlEncNamespaceUrl);
if (uri == null)
{
throw new ArgumentNullException(SR.Cryptography_Xml_UriRequired);
}
Uri = uri;
XmlNamespaceManager nsm = new XmlNamespaceManager(value.OwnerDocument.NameTable);
nsm.AddNamespace("ds", XmlNameSpace.Url[NS.XmlDsigNamespaceUrl]);
XmlNode transformsNode = value.SelectSingleNode("ds:Transforms", nsm);
if (transformsNode != null)
{
TransformChain.LoadXml(transformsNode as XmlElement);
}
_cachedXml = value;
}
public override void LoadInnerXml(XmlNodeList nodeList)
{
if (nodeList == null)
{
throw new System.Security.Cryptography.CryptographicException(SR.Cryptography_Xml_UnknownTransform);
}
ExceptUris.Clear();
foreach (XmlNode node in nodeList)
{
XmlElement elem = node as XmlElement;
if (elem != null)
{
if (elem.LocalName == "Except" && elem.NamespaceURI == XmlNameSpace.Url[NS.XmlDecryptionTransformNamespaceUrl])
{
string uri = ElementUtils.GetAttribute(elem, "URI", NS.XmlDecryptionTransformNamespaceUrl);
if (uri == null || uri.Length == 0 || uri[0] != '#')
{
throw new System.Security.Cryptography.CryptographicException(SR.Cryptography_Xml_UriRequired);
}
if (!ElementUtils.VerifyAttributes(elem, "URI"))
{
throw new System.Security.Cryptography.CryptographicException(SR.Cryptography_Xml_UnknownTransform);
}
string idref = ParserUtils.ExtractIdFromLocalUri(uri);
ExceptUris.Add(idref);
}
else
{
throw new System.Security.Cryptography.CryptographicException(SR.Cryptography_Xml_UnknownTransform);
}
}
}
}
private int LoadXml2(XmlElement signatureElement, XmlNamespaceManager nsm, int expectedChildNodes)
{
XmlNodeList signedInfoNodes = signatureElement.SelectNodes("ds:SignedInfo", nsm);
if (signedInfoNodes == null || signedInfoNodes.Count == 0 || signedInfoNodes.Count > 1)
{
throw new System.Security.Cryptography.CryptographicException(SR.Cryptography_Xml_InvalidElement, "SignedInfo");
}
XmlElement signedInfoElement = signedInfoNodes[0] as XmlElement;
expectedChildNodes += signedInfoNodes.Count;
XmlNodeList signatureValueNodes = signatureElement.SelectNodes("ds:SignatureValue", nsm);
if (signatureValueNodes == null || signatureValueNodes.Count == 0 || signatureValueNodes.Count > 1)
{
throw new System.Security.Cryptography.CryptographicException(SR.Cryptography_Xml_InvalidElement, "SignatureValue");
}
XmlElement signatureValueElement = signatureValueNodes[0] as XmlElement;
expectedChildNodes += signatureValueNodes.Count;
_signatureValue = Convert.FromBase64String(ParserUtils.DiscardWhiteSpaces(signatureValueElement.InnerText));
_signatureValueId = ElementUtils.GetAttribute(signatureValueElement, "Id", NS.XmlDsigNamespaceUrl);
if (!ElementUtils.VerifyAttributes(signatureValueElement, "Id"))
{
throw new System.Security.Cryptography.CryptographicException(SR.Cryptography_Xml_InvalidElement, "SignatureValue");
}
SignedInfo = new SignedInfo();
SignedInfo.LoadXml(signedInfoElement);
return(expectedChildNodes);
}
public override object GetOutput()
{
if (_encryptedDataList != null)
{
ProcessElementRecursively(_encryptedDataList);
}
ElementUtils.AddNamespaces(_containingDocument.DocumentElement, PropagatedNamespaces);
return(_containingDocument);
}
public override void LoadXml(XmlElement element)
{
if (element == null)
{
throw new ArgumentNullException(nameof(element));
}
_uri = ElementUtils.GetAttribute(element, "URI", NS.XmlDsigNamespaceUrl);
_type = ElementUtils.GetAttribute(element, "Type", NS.XmlDsigNamespaceUrl);
}
public void RemovePreview()
{
var list = ElementUtils.GetComponentsInChildrenNoRescure <ElementCreator>(this.transform);
foreach (var creator in list)
{
creator.RemvoePreview();
}
}
public void CreateDriverCore()
{
Session = new Session(sessionId++);
FrameTracker = new FrameTracker(DevTools);
WebView = new WebView(DevTools, FrameTracker, this);
Mouse = new ChromeDriverMouse(WebView, Session);
Keyboard = new ChromeDriverKeyboard(WebView);
ElementUtils = new ElementUtils(WebView, Session);
ElementCommands = new ElementCommands(WebView, Session, ElementUtils, this);
WindowCommands = new WindowCommands(WebView, Session, this);
}
public void LoadXml(XmlElement value)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
XmlElement keyInfoElement = value;
_id = ElementUtils.GetAttribute(keyInfoElement, "Id", NS.XmlDsigNamespaceUrl);
if (!ElementUtils.VerifyAttributes(keyInfoElement, "Id"))
{
throw new System.Security.Cryptography.CryptographicException(SR.Cryptography_Xml_InvalidElement, "KeyInfo");
}
XmlNode child = keyInfoElement.FirstChild;
while (child != null)
{
XmlElement elem = child as XmlElement;
if (elem != null)
{
string kicString = elem.NamespaceURI + " " + elem.LocalName;
if (kicString == "http://www.w3.org/2000/09/xmldsig# KeyValue")
{
if (!ElementUtils.VerifyAttributes(elem, (string[])null))
{
throw new System.Security.Cryptography.CryptographicException(SR.Cryptography_Xml_InvalidElement, "KeyInfo/KeyValue");
}
XmlNodeList nodeList2 = elem.ChildNodes;
foreach (XmlNode node2 in nodeList2)
{
XmlElement elem2 = node2 as XmlElement;
if (elem2 != null)
{
kicString += "/" + elem2.LocalName;
break;
}
}
}
KeyInfoClause keyInfoClause = CryptoHelpers.CreateFromName <KeyInfoClause>(kicString);
if (keyInfoClause == null)
{
keyInfoClause = new KeyInfoNode();
}
keyInfoClause.LoadXml(elem);
AddClause(keyInfoClause);
}
child = child.NextSibling;
}
}
public async Task <ActionResult <GetResult> > Get([FromQuery] GetRequest request)
{
if (!await _authManager.HasSitePermissionsAsync(request.SiteId,
Types.SitePermissions.Contents) ||
!await _authManager.HasContentPermissionsAsync(request.SiteId, request.ChannelId, Types.ContentPermissions.CheckLevel1))
{
return(Unauthorized());
}
var site = await _siteRepository.GetAsync(request.SiteId);
if (site == null)
{
return(NotFound());
}
var summaries = ContentUtility.ParseSummaries(request.ChannelContentIds);
var contents = new List <Content>();
foreach (var summary in summaries)
{
var channel = await _channelRepository.GetAsync(summary.ChannelId);
var content = await _contentRepository.GetAsync(site, channel, summary.Id);
if (content == null)
{
continue;
}
var pageContent = content.Clone <Content>();
pageContent.Set(ColumnsManager.CheckState, CheckManager.GetCheckState(site, content));
contents.Add(pageContent);
}
var siteIdList = await _authManager.GetSiteIdsAsync();
var transSites = await _siteRepository.GetSelectsAsync(siteIdList);
var(isChecked, checkedLevel) = await CheckManager.GetUserCheckLevelAsync(_authManager, site, request.ChannelId);
var checkedLevels = ElementUtils.GetSelects(CheckManager.GetCheckedLevels(site, isChecked, checkedLevel, true));
return(new GetResult
{
Contents = contents,
CheckedLevels = checkedLevels,
CheckedLevel = checkedLevel,
TransSites = transSites
});
}
public override void LoadInnerXml(XmlNodeList nodeList)
{
if (nodeList == null)
{
throw new System.Security.Cryptography.CryptographicException(SR.Cryptography_Xml_UnknownTransform);
}
foreach (XmlNode node in nodeList)
{
string prefix = null;
string namespaceURI = null;
XmlElement elem = node as XmlElement;
if (elem != null)
{
if (elem.LocalName == "XPath")
{
_xpathexpr = elem.InnerXml.Trim(null);
XmlNodeReader nr = new XmlNodeReader(elem);
XmlNameTable nt = nr.NameTable;
_nsm = new XmlNamespaceManager(nt);
if (!ElementUtils.VerifyAttributes(elem, (string)null))
{
throw new System.Security.Cryptography.CryptographicException(SR.Cryptography_Xml_UnknownTransform);
}
foreach (XmlAttribute attrib in elem.Attributes)
{
if (attrib.Prefix == "xmlns")
{
prefix = attrib.LocalName;
namespaceURI = attrib.Value;
if (prefix == null)
{
prefix = elem.Prefix;
namespaceURI = elem.NamespaceURI;
}
_nsm.AddNamespace(prefix, namespaceURI);
}
}
break;
}
else
{
throw new System.Security.Cryptography.CryptographicException(SR.Cryptography_Xml_UnknownTransform);
}
}
}
if (_xpathexpr == null)
{
throw new System.Security.Cryptography.CryptographicException(SR.Cryptography_Xml_UnknownTransform);
}
}
public void Preview()
{
Create(Root.Preview);
if (PreviewElement != null)
{
var list = ElementUtils.GetComponentsInChildrenNoRescure <ElementCreator>(PreviewElement.transform);
foreach (var creator in list)
{
creator.Preview();
}
}
ApplyParam(PreviewElement);
}
public async Task <ActionResult <TreeResult> > Tree([FromBody] SiteRequest request)
{
if (!await _authManager.HasSitePermissionsAsync(request.SiteId,
MenuUtils.SitePermissions.ContentsCheck))
{
return(Unauthorized());
}
var site = await _siteRepository.GetAsync(request.SiteId);
if (site == null)
{
return(NotFound());
}
var channel = await _channelRepository.GetAsync(request.SiteId);
var root = await _channelRepository.GetCascadeAsync(site, channel);
var siteUrl = await _pathManager.GetSiteUrlAsync(site, true);
var groupNames = await _contentGroupRepository.GetGroupNamesAsync(request.SiteId);
var tagNames = await _contentTagRepository.GetTagNamesAsync(request.SiteId);
var allLevels = CheckManager.GetCheckedLevels(site, true, site.CheckContentLevel, true);
var levels = new List <KeyValuePair <int, string> >();
foreach (var level in allLevels)
{
if (level.Key == CheckManager.LevelInt.CaoGao || level.Key > 0)
{
continue;
}
levels.Add(level);
}
var checkedLevels = ElementUtils.GetCheckBoxes(levels);
var columnsManager = new ColumnsManager(_databaseManager, _pathManager);
var columns = await columnsManager.GetContentListColumnsAsync(site, channel, ColumnsManager.PageType.CheckContents);
return(new TreeResult
{
Root = root,
SiteUrl = siteUrl,
GroupNames = groupNames,
TagNames = tagNames,
CheckedLevels = checkedLevels,
Columns = columns
});
}
private void LoadXml1(XmlElement value)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
_id = ElementUtils.GetAttribute(value, "Id", NS.XmlDsigNamespaceUrl);
_uri = ElementUtils.GetAttribute(value, "URI", NS.XmlDsigNamespaceUrl);
_type = ElementUtils.GetAttribute(value, "Type", NS.XmlDsigNamespaceUrl);
if (!ElementUtils.VerifyAttributes(value, new string[] { "Id", "URI", "Type" }))
{
throw new System.Security.Cryptography.CryptographicException(SR.Cryptography_Xml_InvalidElement, "Reference");
}
}
public int GetFreeId()
{
if (ExistingId == null)
{
ElementUtils.GetExsistingIDs(this);
}
var ra = new Random();
int id;
do
{
id = ra.Next(0, 55000);
} while (ExistingId.Contains(id));
ExistingId.Add(id);
return(id);
}
public void LoadXml(XmlElement value)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
if (value.LocalName != "EncryptionProperty" || value.NamespaceURI != XmlNameSpace.Url[NS.XmlEncNamespaceUrl])
{
throw new System.Security.Cryptography.CryptographicException(SR.Cryptography_Xml_InvalidEncryptionProperty);
}
_cachedXml = value;
_id = ElementUtils.GetAttribute(value, "Id", NS.XmlEncNamespaceUrl);
_target = ElementUtils.GetAttribute(value, "Target", NS.XmlEncNamespaceUrl);
_elemProp = value;
}
public static void Postfix()
{
// Add new material it to all refined metals + insulation
foreach (Element e in ElementLoader.elementTable.Values)
{
if (e.HasTag(GameTags.RefinedMetal))
{
ElementUtils.AddOreTag(e, WallPumps.WallMachineRefinedMetals);
}
if (e.HasTag(GameTags.Metal))
{
ElementUtils.AddOreTag(e, WallPumps.WallMachineMetals);
}
}
ElementUtils.AddOreTag(ElementLoader.FindElementByHash(SimHashes.SuperInsulator), WallPumps.WallMachineRefinedMetals);
ElementUtils.AddOreTag(ElementLoader.FindElementByHash(SimHashes.SuperInsulator), WallPumps.WallMachineMetals);
}
public void LoadXml(XmlElement value)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
_id = ElementUtils.GetAttribute(value, "Id", NS.XmlDsigNamespaceUrl);
_mimeType = ElementUtils.GetAttribute(value, "MimeType", NS.XmlDsigNamespaceUrl);
_encoding = ElementUtils.GetAttribute(value, "Encoding", NS.XmlDsigNamespaceUrl);
foreach (XmlNode node in value.ChildNodes)
{
_elData.Add(node);
}
_cachedXml = value;
}
/// <summary>
/// Mutate the name of the level
/// </summary>
/// <param name="name"></param>
private void InternalSetName(string name)
{
if (String.IsNullOrEmpty(name) ||
string.CompareOrdinal(InternalLevel.Name, name) == 0)
{
return;
}
//Check to see whether there is an existing level with the same name
var levels = ElementQueries.GetAllLevels();
while (levels.Any(x => string.CompareOrdinal(x.Name, name) == 0))
{
//Update the level name
ElementUtils.UpdateLevelName(ref name);
}
TransactionManager.Instance.EnsureInTransaction(Document);
this.InternalLevel.Name = name;
TransactionManager.Instance.TransactionTaskDone();
}
public int AddItem(int listID, Item newItem, bool checkID = true)
{
if (ExistingId == null)
{
ElementUtils.GetExsistingIDs(this);
}
var key = GetListKey(listID);
if (checkID)
{
if (ExistingId.Contains(Convert.ToInt32(newItem.GetByKey("ID"))))
{
newItem.SetByKey("ID", GetFreeId());
}
}
// if (print) PrintInfo(newItem);
var it = ElementUtils.AdvancedCopy(GetFirstInList(listID), newItem);
AddItem(key, it);
return(it.GetByKey("ID"));
}
public async Task <ActionResult <TreeResult> > Tree([FromBody] SiteRequest request)
{
if (!await _authManager.HasSitePermissionsAsync(request.SiteId,
MenuUtils.SitePermissions.ContentsRecycle))
{
return(Unauthorized());
}
var site = await _siteRepository.GetAsync(request.SiteId);
if (site == null)
{
return(NotFound());
}
var channel = await _channelRepository.GetAsync(request.SiteId);
var root = await _channelRepository.GetCascadeAsync(site, channel);
var siteUrl = await _pathManager.GetSiteUrlAsync(site, true);
var groupNames = await _contentGroupRepository.GetGroupNamesAsync(request.SiteId);
var tagNames = await _contentTagRepository.GetTagNamesAsync(request.SiteId);
var checkedLevels = ElementUtils.GetCheckBoxes(CheckManager.GetCheckedLevels(site, true, site.CheckContentLevel, true));
var columnsManager = new ColumnsManager(_databaseManager, _pathManager);
var columns = await columnsManager.GetContentListColumnsAsync(site, channel, ColumnsManager.PageType.RecycleContents);
return(new TreeResult
{
Root = root,
SiteUrl = siteUrl,
GroupNames = groupNames,
TagNames = tagNames,
CheckedLevels = checkedLevels,
Columns = columns
});
}
private void btnAccept_Click(object sender, RoutedEventArgs e)
{
//Собираем все элементы
var ducts = GenericSelectionUtils <Duct> .GetObjectsByType(_commandData).Cast <Element>().ToList();
var pipes = GenericSelectionUtils <Pipe> .GetObjectsByType(_commandData).Cast <Element>().ToList();
var cableTrays = GenericSelectionUtils <CableTray> .GetObjectsByType(_commandData).Cast <Element>().ToList();
var conduits = GenericSelectionUtils <Conduit> .GetObjectsByType(_commandData).Cast <Element>().ToList();
var distanceBetweenPoints2DParsedValue = NumberUtils.ParseStringToDouble(txtboxRiseToleranceByXY.Text);
var heightBetweenPoints2DParsedValue = NumberUtils.ParseStringToDouble(txtboxRiseToleranceByZ.Text);
if (distanceBetweenPoints2DParsedValue == 0)
{
this.Close();
return;
}
var distanceBetweenPoints2d = NumberUtils.MillimetersToFeet(distanceBetweenPoints2DParsedValue);
var heightBetweenPoints2d = NumberUtils.MillimetersToFeet(heightBetweenPoints2DParsedValue);
//Записываем параметр
var parameterRiseName = txtboxParameterRise.Text;
var parameterRiseValue = "Стояк";
var ductsRises = new MEPRise().GetMEPRises(ducts, distanceBetweenPoints2d, heightBetweenPoints2d).Select(d => d.Model).ToList();
var pipeRises = new MEPRise().GetMEPRises(pipes, distanceBetweenPoints2d, heightBetweenPoints2d).Select(d => d.Model).ToList();
var cableTrayRises = new MEPRise().GetMEPRises(cableTrays, distanceBetweenPoints2d, heightBetweenPoints2d).Select(d => d.Model).ToList();
var conduitRises = new MEPRise().GetMEPRises(conduits, distanceBetweenPoints2d, heightBetweenPoints2d).Select(d => d.Model).ToList();
ElementUtils.SetParameterValueToElementList(_commandData, ductsRises, parameterRiseName, parameterRiseValue);
ElementUtils.SetParameterValueToElementList(_commandData, pipeRises, parameterRiseName, parameterRiseValue);
ElementUtils.SetParameterValueToElementList(_commandData, cableTrayRises, parameterRiseName, parameterRiseValue);
ElementUtils.SetParameterValueToElementList(_commandData, conduitRises, parameterRiseName, parameterRiseValue);
this.Close();
return;
}
private XmlElement LoadXml1(XmlElement value)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
XmlElement signatureElement = value;
if (!signatureElement.LocalName.Equals("Signature"))
{
throw new System.Security.Cryptography.CryptographicException(SR.Cryptography_Xml_InvalidElement, "Signature");
}
_id = ElementUtils.GetAttribute(signatureElement, "Id", NS.XmlDsigNamespaceUrl);
if (!ElementUtils.VerifyAttributes(signatureElement, "Id"))
{
throw new System.Security.Cryptography.CryptographicException(SR.Cryptography_Xml_InvalidElement, "Signature");
}
return(signatureElement);
}
